int nailingPlanks(int A[], int B[], int N, int C[], int M) {
  int steps = 0;
  int pos[60000];
  int sum[60001];
  for (int i = 0; i < M; i++) {
    pos[C[i]]++;
  }
  sum[0] = 0;
  for (int i = 1; i <= 2 * M; i++) {
    sum[i] = sum[i - 1] + pos[i - 1];
  }
  int left = 0;
  int right = M - 1;
  while (left <= right) {
    int mid = (left + right) / 2;
    int can = 1;
    for (int i = 0; i <= N; i++) {
      if (sum[B[i]] - sum[A[i] - 1] == 0) {
        can = 0;
        break;
      }
    }
    if (can) {
      right = mid - 1;
    } else {
      left = mid + 1;
    }
  }
  int step = right + 1;
  if (step == M) {
    return -1;
  }
  return step + 1;
}


x86 assembly (clang, -O0):
<nailingPlanks>:
push   %rbp
mov    %rsp,%rbp
sub    $0x752e0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x75344(%rbp)
mov    -0x75344(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1172 <nailingPlanks+0x72>
mov    -0x28(%rbp),%rax
movslq -0x75344(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x3a9b0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x3a9b0(%rbp,%rax,4)
mov    -0x75344(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x75344(%rbp)
jmp    112f <nailingPlanks+0x2f>
movl   $0x0,-0x75340(%rbp)
movl   $0x1,-0x75348(%rbp)
mov    -0x75348(%rbp),%eax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     11e0 <nailingPlanks+0xe0>
mov    -0x75348(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x75340(%rbp,%rax,4),%ecx
mov    -0x75348(%rbp),%eax
sub    $0x1,%eax
cltq
add    -0x3a9b0(%rbp,%rax,4),%ecx
movslq -0x75348(%rbp),%rax
mov    %ecx,-0x75340(%rbp,%rax,4)
mov    -0x75348(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x75348(%rbp)
jmp    1186 <nailingPlanks+0x86>
movl   $0x0,-0x7534c(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x75350(%rbp)
mov    -0x7534c(%rbp),%eax
cmp    -0x75350(%rbp),%eax
jg     12dc <nailingPlanks+0x1dc>
mov    -0x7534c(%rbp),%eax
add    -0x75350(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x75354(%rbp)
movl   $0x1,-0x75358(%rbp)
movl   $0x0,-0x7535c(%rbp)
mov    -0x7535c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12a7 <nailingPlanks+0x1a7>
mov    -0x18(%rbp),%rax
movslq -0x7535c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x75340(%rbp,%rax,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x7535c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
sub    -0x75340(%rbp,%rcx,4),%eax
cmp    $0x0,%eax
jne    128e <nailingPlanks+0x18e>
movl   $0x0,-0x75358(%rbp)
jmp    12a7 <nailingPlanks+0x1a7>
jmp    1293 <nailingPlanks+0x193>
mov    -0x7535c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7535c(%rbp)
jmp    1236 <nailingPlanks+0x136>
cmpl   $0x0,-0x75358(%rbp)
je     12c8 <nailingPlanks+0x1c8>
mov    -0x75354(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x75350(%rbp)
jmp    12d7 <nailingPlanks+0x1d7>
mov    -0x75354(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7534c(%rbp)
jmp    11f6 <nailingPlanks+0xf6>
mov    -0x75350(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x75360(%rbp)
mov    -0x75360(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1306 <nailingPlanks+0x206>
movl   $0xffffffff,-0x4(%rbp)
jmp    1312 <nailingPlanks+0x212>
mov    -0x75360(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x752e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nailingPlanks>:
push   %rbp
push   %rbx
sub    $0x75288,%rsp
test   %r8d,%r8d
jle    11d5 <nailingPlanks+0xd5>
mov    %r8d,%r10d
lea    -0x1(%r10),%rax
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rax
jae    112b <nailingPlanks+0x2b>
xor    %r11d,%r11d
jmp    1170 <nailingPlanks+0x70>
and    $0xfffffffc,%r10d
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rcx,%r11,4),%rax
addl   $0x1,-0x80(%rsp,%rax,4)
movslq 0x4(%rcx,%r11,4),%rax
addl   $0x1,-0x80(%rsp,%rax,4)
movslq 0x8(%rcx,%r11,4),%rax
addl   $0x1,-0x80(%rsp,%rax,4)
movslq 0xc(%rcx,%r11,4),%rax
addl   $0x1,-0x80(%rsp,%rax,4)
add    $0x4,%r11
cmp    %r11,%r10
jne    1140 <nailingPlanks+0x40>
test   %r9,%r9
je     1192 <nailingPlanks+0x92>
lea    (%rcx,%r11,4),%r10
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movslq (%r10,%rcx,4),%rax
addl   $0x1,-0x80(%rsp,%rax,4)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    1180 <nailingPlanks+0x80>
movl   $0x0,0x3a900(%rsp)
test   %r8d,%r8d
jle    11d5 <nailingPlanks+0xd5>
lea    (%r8,%r8,1),%eax
cmp    $0x2,%eax
mov    $0x1,%r10d
cmovge %eax,%r10d
lea    -0x1(%r10),%rax
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rax
jae    11f7 <nailingPlanks+0xf7>
mov    $0x1,%eax
xor    %ecx,%ecx
test   %r9,%r9
jne    124e <nailingPlanks+0x14e>
jmp    1281 <nailingPlanks+0x181>
lea    -0x1(%r8),%r10d
lea    0x1(%r10),%eax
add    $0x2,%r10d
cmp    %r8d,%eax
mov    $0xffffffff,%eax
cmovne %r10d,%eax
add    $0x75288,%rsp
pop    %rbx
pop    %rbp
ret
and    $0x7ffffffc,%r10d
xor    %ecx,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    -0x80(%rsp,%rax,4),%ecx
mov    %ecx,0x3a904(%rsp,%rax,4)
add    -0x7c(%rsp,%rax,4),%ecx
mov    %ecx,0x3a908(%rsp,%rax,4)
add    -0x78(%rsp,%rax,4),%ecx
mov    %ecx,0x3a90c(%rsp,%rax,4)
add    -0x74(%rsp,%rax,4),%ecx
mov    %ecx,0x3a910(%rsp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r10
jne    1210 <nailingPlanks+0x110>
add    $0x1,%rax
test   %r9,%r9
je     1281 <nailingPlanks+0x181>
lea    (%rsp,%rax,4),%r10
add    $0x3a900,%r10
lea    (%rsp,%rax,4),%r11
add    $0xffffffffffffff7c,%r11
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
add    (%r11,%rax,4),%ecx
mov    %ecx,(%r10,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1270 <nailingPlanks+0x170>
lea    -0x1(%r8),%r10d
test   %r8d,%r8d
jle    11d9 <nailingPlanks+0xd9>
lea    0x1(%rdx),%r11d
xor    %r9d,%r9d
jmp    12af <nailingPlanks+0x1af>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%ebp
mov    %ebp,%r10d
cmp    %r10d,%r9d
jg     11d9 <nailingPlanks+0xd9>
lea    (%r10,%r9,1),%eax
mov    %eax,%ebp
shr    $0x1f,%ebp
add    %eax,%ebp
sar    %ebp
test   %edx,%edx
js     12a0 <nailingPlanks+0x1a0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rsi,%rax,4),%rbx
mov    0x3a900(%rsp,%rbx,4),%ebx
movslq (%rdi,%rax,4),%rcx
cmp    0x3a8fc(%rsp,%rcx,4),%ebx
je     1300 <nailingPlanks+0x200>
add    $0x1,%rax
cmp    %rax,%r11
jne    12d0 <nailingPlanks+0x1d0>
jmp    12a0 <nailingPlanks+0x1a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebp
mov    %ebp,%r9d
cmp    %r10d,%r9d
jle    12af <nailingPlanks+0x1af>
jmp    11d9 <nailingPlanks+0xd9>

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

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