#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*/ printf(char *, ...);
int scanf(char *, long long *);
int main() {
  long long int arr[1000], total[1000];
  long long int i, j, n, l, r, t = 1;
  n = 0;
  while (scanf("%lld", &arr[n]) == 1) {
    if (arr[n] != -1) {
      n++;
      continue;
    } else if (arr[n] == -1 && n == 0)
      break;
    else {
      for (i = 0; i <= n; i++)
        total[i] = 1;
      for (i = 0; i <= n; i++) {
        l = i;
        if (i != 0)
          for (j = i - 1; j >= 0; j--) {
            if (arr[l] < arr[j]) {
              l = j;
              total[i]++;
            }
          }
        r = i;
        if (i != n)
          for (j = i + 1; j < n; j++) {
            if (arr[r] > arr[j]) {
              r = j;
              total[i]++;
            }
          }
      }
      int num = 0;
      for (i = 0; i < n; i++) {
        if (total[i] > num)
          num = total[i];
      }
      if (t > 1)
        printf("\n");
      printf("Test #%lld:\n  maximum possible interceptions: %d\n", t, num);
      n = 0;
      t++;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3ed0,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x1,-0x3ec0(%rbp)
movq   $0x0,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rax
lea    -0x1f50(%rbp),%rsi
shl    $0x3,%rax
add    %rax,%rsi
lea    0xe9c(%rip),%rdi
call   1040 <scanf@plt>
cmp    $0x1,%eax
jne    1483 <main+0x363>
mov    -0x3ea8(%rbp),%rax
cmpq   $0xffffffffffffffff,-0x1f50(%rbp,%rax,8)
ff ff
je     119f <main+0x7f>
mov    -0x3ea8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3ea8(%rbp)
jmp    1148 <main+0x28>
mov    -0x3ea8(%rbp),%rax
cmpq   $0xffffffffffffffff,-0x1f50(%rbp,%rax,8)
ff ff
jne    11c8 <main+0xa8>
cmpq   $0x0,-0x3ea8(%rbp)
jne    11c8 <main+0xa8>
jmp    1483 <main+0x363>
movq   $0x0,-0x3e98(%rbp)
mov    -0x3e98(%rbp),%rax
cmp    -0x3ea8(%rbp),%rax
jg     1211 <main+0xf1>
mov    -0x3e98(%rbp),%rax
movq   $0x1,-0x3e90(%rbp,%rax,8)
mov    -0x3e98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3e98(%rbp)
jmp    11d3 <main+0xb3>
movq   $0x0,-0x3e98(%rbp)
mov    -0x3e98(%rbp),%rax
cmp    -0x3ea8(%rbp),%rax
jg     13ac <main+0x28c>
mov    -0x3e98(%rbp),%rax
mov    %rax,-0x3eb0(%rbp)
cmpq   $0x0,-0x3e98(%rbp)
je     12da <main+0x1ba>
mov    -0x3e98(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x3ea0(%rbp)
cmpq   $0x0,-0x3ea0(%rbp)
jl     12d5 <main+0x1b5>
mov    -0x3eb0(%rbp),%rax
mov    -0x1f50(%rbp,%rax,8),%rax
ff
mov    -0x3ea0(%rbp),%rcx
cmp    -0x1f50(%rbp,%rcx,8),%rax
ff
jge    12b9 <main+0x199>
mov    -0x3ea0(%rbp),%rax
mov    %rax,-0x3eb0(%rbp)
mov    -0x3e98(%rbp),%rax
mov    -0x3e90(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x3e90(%rbp,%rax,8)
ff
jmp    12be <main+0x19e>
mov    -0x3ea0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x3ea0(%rbp)
jmp    125e <main+0x13e>
jmp    12da <main+0x1ba>
mov    -0x3e98(%rbp),%rax
mov    %rax,-0x3eb8(%rbp)
mov    -0x3e98(%rbp),%rax
cmp    -0x3ea8(%rbp),%rax
je     1390 <main+0x270>
mov    -0x3e98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3ea0(%rbp)
mov    -0x3ea0(%rbp),%rax
cmp    -0x3ea8(%rbp),%rax
jge    138b <main+0x26b>
mov    -0x3eb8(%rbp),%rax
mov    -0x1f50(%rbp,%rax,8),%rax
ff
mov    -0x3ea0(%rbp),%rcx
cmp    -0x1f50(%rbp,%rcx,8),%rax
ff
jle    136f <main+0x24f>
mov    -0x3ea0(%rbp),%rax
mov    %rax,-0x3eb8(%rbp)
mov    -0x3e98(%rbp),%rax
mov    -0x3e90(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x3e90(%rbp,%rax,8)
ff
jmp    1374 <main+0x254>
mov    -0x3ea0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3ea0(%rbp)
jmp    130e <main+0x1ee>
jmp    1390 <main+0x270>
jmp    1395 <main+0x275>
mov    -0x3e98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3e98(%rbp)
jmp    121c <main+0xfc>
movl   $0x0,-0x3ec4(%rbp)
movq   $0x0,-0x3e98(%rbp)
mov    -0x3e98(%rbp),%rax
cmp    -0x3ea8(%rbp),%rax
jge    1425 <main+0x305>
mov    -0x3e98(%rbp),%rax
mov    -0x3e90(%rbp,%rax,8),%rax
ff
movslq -0x3ec4(%rbp),%rcx
cmp    %rcx,%rax
jle    1409 <main+0x2e9>
mov    -0x3e98(%rbp),%rax
mov    -0x3e90(%rbp,%rax,8),%rax
ff
mov    %eax,-0x3ec4(%rbp)
jmp    140e <main+0x2ee>
mov    -0x3e98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3e98(%rbp)
jmp    13c1 <main+0x2a1>
cmpq   $0x1,-0x3ec0(%rbp)
01
jle    1441 <main+0x321>
lea    0xbfb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x3ec0(%rbp),%rsi
mov    -0x3ec4(%rbp),%edx
lea    0xbb0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movq   $0x0,-0x3ea8(%rbp)
mov    -0x3ec0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3ec0(%rbp)
jmp    147e <main+0x35e>
jmp    1148 <main+0x28>
xor    %eax,%eax
add    $0x3ed0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3e88,%rsp
lea    0xec8(%rip),%rdi
lea    0x1f40(%rsp),%rsi
call   1050 <scanf@plt>
cmp    $0x1,%eax
jne    150a <main+0x3da>
mov    $0x1,%r15d
lea    0xea5(%rip),%r13
movaps 0xe8e(%rip),%xmm0
xor    %r14d,%r14d
mov    $0x1,%ebp
lea    0x1f48(%rsp),%rbx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
cmpq   $0xffffffffffffffff,-0x8(%rbx)
je     11d0 <main+0xa0>
add    $0x1,%r12
mov    %r13,%rdi
mov    %rbx,%rsi
call   1050 <scanf@plt>
movaps 0xe53(%rip),%xmm0
add    $0x8,%rbx
add    $0x1,%rbp
add    $0x1,%r14b
cmp    $0x1,%eax
je     1190 <main+0x60>
jmp    150a <main+0x3da>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r12,%r12
je     150a <main+0x3da>
cmp    $0x3,%r12
jae    11f0 <main+0xc0>
xor    %eax,%eax
jmp    1300 <main+0x1d0>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r12),%rcx
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    $0x1c,%rsi
jae    1218 <main+0xe8>
xor    %edi,%edi
jmp    12b1 <main+0x181>
mov    %rbp,%rsi
and    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm0,(%rsp,%rdi,8)
movaps %xmm0,0x10(%rsp,%rdi,8)
movaps %xmm0,0x20(%rsp,%rdi,8)
movaps %xmm0,0x30(%rsp,%rdi,8)
movaps %xmm0,0x40(%rsp,%rdi,8)
movaps %xmm0,0x50(%rsp,%rdi,8)
movaps %xmm0,0x60(%rsp,%rdi,8)
movaps %xmm0,0x70(%rsp,%rdi,8)
movaps %xmm0,0x80(%rsp,%rdi,8)
movaps %xmm0,0x90(%rsp,%rdi,8)
movaps %xmm0,0xa0(%rsp,%rdi,8)
movaps %xmm0,0xb0(%rsp,%rdi,8)
movaps %xmm0,0xc0(%rsp,%rdi,8)
movaps %xmm0,0xd0(%rsp,%rdi,8)
movaps %xmm0,0xe0(%rsp,%rdi,8)
movaps %xmm0,0xf0(%rsp,%rdi,8)
add    $0x20,%rdi
add    $0xfffffffffffffff8,%rsi
jne    1240 <main+0x110>
test   $0x7,%dl
je     12f2 <main+0x1c2>
lea    0x10(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdx
mov    %ebp,%ebx
and    $0x1c,%bl
add    $0xfc,%bl
shr    $0x2,%bl
add    $0x1,%bl
movzbl %bl,%esi
and    $0x7,%esi
shl    $0x5,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movaps %xmm0,-0x10(%rdx,%rdi,1)
movaps %xmm0,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    12e0 <main+0x1b0>
cmp    %rax,%rcx
je     1311 <main+0x1e1>
nopw   0x0(%rax,%rax,1)
movq   $0x1,(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1300 <main+0x1d0>
xor    %ecx,%ecx
jmp    1329 <main+0x1f9>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rax,%r12
je     1420 <main+0x2f0>
mov    %rcx,%rax
test   %rcx,%rcx
je     1370 <main+0x240>
mov    %rax,%rcx
mov    %rax,%rdx
test   $0x1,%al
je     1359 <main+0x229>
lea    -0x1(%rax),%rcx
mov    0x1f40(%rsp,%rax,8),%rdx
cmp    0x1f38(%rsp,%rax,8),%rdx
jge    1361 <main+0x231>
addq   $0x1,(%rsp,%rax,8)
mov    %rcx,%rdx
cmp    $0x1,%rax
je     1370 <main+0x240>
jmp    13c0 <main+0x290>
mov    %rax,%rdx
cmp    $0x1,%rax
jne    13c0 <main+0x290>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%rcx
cmp    %rax,%r12
je     1320 <main+0x1f0>
cmp    %r12,%rcx
jae    1320 <main+0x1f0>
mov    %rcx,%rdx
mov    %rax,%rsi
jmp    1399 <main+0x269>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r12,%rdx
jae    1320 <main+0x1f0>
mov    0x1f40(%rsp,%rsi,8),%rdi
cmp    0x1f40(%rsp,%rdx,8),%rdi
jle    1390 <main+0x260>
addq   $0x1,(%rsp,%rax,8)
mov    %rdx,%rsi
jmp    1390 <main+0x260>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xfffffffffffffffe,%rcx
jmp    13e1 <main+0x2b1>
cs nopw 0x0(%rax,%rax,1)
lea    -0x2(%rcx),%rsi
add    $0x2,%rcx
cmp    $0x2,%rcx
mov    %rsi,%rcx
jle    1370 <main+0x240>
mov    0x1f40(%rsp,%rdx,8),%rsi
cmp    0x1f48(%rsp,%rcx,8),%rsi
jge    13fc <main+0x2cc>
lea    0x1(%rcx),%rdx
addq   $0x1,(%rsp,%rax,8)
mov    0x1f40(%rsp,%rdx,8),%rsi
cmp    0x1f40(%rsp,%rcx,8),%rsi
jge    13d0 <main+0x2a0>
addq   $0x1,(%rsp,%rax,8)
mov    %rcx,%rdx
jmp    13d0 <main+0x2a0>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r12),%rax
cmp    $0x3,%rax
jae    14b0 <main+0x380>
xor    %ebx,%ebx
xor    %eax,%eax
test   $0x3,%r12b
je     1466 <main+0x336>
lea    (%rsp,%rax,8),%rax
movzbl %r14b,%ecx
and    $0x3,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movslq %ebx,%rbx
cmp    %rbx,%rsi
cmovg  %esi,%ebx
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1450 <main+0x320>
cmp    $0x2,%r15
jb     1476 <main+0x346>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb98(%rip),%rdi
mov    %r15,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r15
mov    %r13,%rdi
lea    0x1f40(%rsp),%rsi
call   1050 <scanf@plt>
cmp    $0x1,%eax
movaps 0xb59(%rip),%xmm0
je     1172 <main+0x42>
jmp    150a <main+0x3da>
nop
mov    %r12,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %ebx,%ebx
xor    %eax,%eax
jmp    14cd <main+0x39d>
nopl   (%rax)
add    $0x4,%rax
cmp    %rax,%rcx
je     1433 <main+0x303>
movslq %ebx,%rdx
mov    (%rsp,%rax,8),%rsi
cmp    %rdx,%rsi
jg     14db <main+0x3ab>
mov    %ebx,%esi
mov    0x8(%rsp,%rax,8),%rdx
movslq %esi,%rdi
cmp    %rdi,%rdx
jg     14ea <main+0x3ba>
mov    %esi,%edx
mov    0x10(%rsp,%rax,8),%rsi
movslq %edx,%rdi
cmp    %rdi,%rsi
jg     14f9 <main+0x3c9>
mov    %edx,%esi
mov    0x18(%rsp,%rax,8),%rbx
movslq %esi,%rdx
cmp    %rdx,%rbx
jg     14c0 <main+0x390>
mov    %esi,%ebx
jmp    14c0 <main+0x390>
xor    %eax,%eax
add    $0x3e88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"%lld\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [50 x i8] c"Test #%lld:\0A maximum possible interceptions: %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [1000 x i64]
%3 = alloca [1000 x i64]
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
store i32 0, i32* %1
store i64 1, i64* %9
store i64 0, i64* %6
br label %11
11: ; preds = %146, %21, %0
%12 = load i64, i64* %6
%13 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %12
%14 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i64* %13)
%15 = icmp eq i32 %14, 1
br i1 %15, label %16, label %147
16: ; preds = %11
%17 = load i64, i64* %6
%18 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %17
%19 = load i64, i64* %18
%20 = icmp ne i64 %19, -1
br i1 %20, label %21, label %24
21: ; preds = %16
%22 = load i64, i64* %6
%23 = add nsw i64 %22, 1
store i64 %23, i64* %6
br label %11
24: ; preds = %16
%25 = load i64, i64* %6
%26 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %25
%27 = load i64, i64* %26
%28 = icmp eq i64 %27, -1
br i1 %28, label %29, label %33
29: ; preds = %24
%30 = load i64, i64* %6
%31 = icmp eq i64 %30, 0
br i1 %31, label %32, label %33
32: ; preds = %29
br label %147
33: ; preds = %29, %24
store i64 0, i64* %4
br label %34
34: ; preds = %41, %33
%35 = load i64, i64* %4
%36 = load i64, i64* %6
%37 = icmp sle i64 %35, %36
br i1 %37, label %38, label %44
38: ; preds = %34
%39 = load i64, i64* %4
%40 = getelementptr inbounds [1000 x i64], [1000 x i64]* %3, i64 0, i64 %39
store i64 1, i64* %40
br label %41
41: ; preds = %38
%42 = load i64, i64* %4
%43 = add nsw i64 %42, 1
store i64 %43, i64* %4
br label %34
44: ; preds = %34
store i64 0, i64* %4
br label %45
45: ; preds = %110, %44
%46 = load i64, i64* %4
%47 = load i64, i64* %6
%48 = icmp sle i64 %46, %47
br i1 %48, label %49, label %113
49: ; preds = %45
%50 = load i64, i64* %4
store i64 %50, i64* %7
%51 = load i64, i64* %4
%52 = icmp ne i64 %51, 0
br i1 %52, label %53, label %78
53: ; preds = %49
%54 = load i64, i64* %4
%55 = sub nsw i64 %54, 1
store i64 %55, i64* %5
br label %56
56: ; preds = %74, %53
%57 = load i64, i64* %5
%58 = icmp sge i64 %57, 0
br i1 %58, label %59, label %77
59: ; preds = %56
%60 = load i64, i64* %7
%61 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %60
%62 = load i64, i64* %61
%63 = load i64, i64* %5
%64 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %63
%65 = load i64, i64* %64
%66 = icmp slt i64 %62, %65
br i1 %66, label %67, label %73
67: ; preds = %59
%68 = load i64, i64* %5
store i64 %68, i64* %7
%69 = load i64, i64* %4
%70 = getelementptr inbounds [1000 x i64], [1000 x i64]* %3, i64 0, i64 %69
%71 = load i64, i64* %70
%72 = add nsw i64 %71, 1
store i64 %72, i64* %70
br label %73
73: ; preds = %67, %59
br label %74
74: ; preds = %73
%75 = load i64, i64* %5
%76 = add nsw i64 %75, -1
store i64 %76, i64* %5
br label %56
77: ; preds = %56
br label %78
78: ; preds = %77, %49
%79 = load i64, i64* %4
store i64 %79, i64* %8
%80 = load i64, i64* %4
%81 = load i64, i64* %6
%82 = icmp ne i64 %80, %81
br i1 %82, label %83, label %109
83: ; preds = %78
%84 = load i64, i64* %4
%85 = add nsw i64 %84, 1
store i64 %85, i64* %5
br label %86
86: ; preds = %105, %83
%87 = load i64, i64* %5
%88 = load i64, i64* %6
%89 = icmp slt i64 %87, %88
br i1 %89, label %90, label %108
90: ; preds = %86
%91 = load i64, i64* %8
%92 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %91
%93 = load i64, i64* %92
%94 = load i64, i64* %5
%95 = getelementptr inbounds [1000 x i64], [1000 x i64]* %2, i64 0, i64 %94
%96 = load i64, i64* %95
%97 = icmp sgt i64 %93, %96
br i1 %97, label %98, label %104
98: ; preds = %90
%99 = load i64, i64* %5
store i64 %99, i64* %8
%100 = load i64, i64* %4
%101 = getelementptr inbounds [1000 x i64], [1000 x i64]* %3, i64 0, i64 %100
%102 = load i64, i64* %101
%103 = add nsw i64 %102, 1
store i64 %103, i64* %101
br label %104
104: ; preds = %98, %90
br label %105
105: ; preds = %104
%106 = load i64, i64* %5
%107 = add nsw i64 %106, 1
store i64 %107, i64* %5
br label %86
108: ; preds = %86
br label %109
109: ; preds = %108, %78
br label %110
110: ; preds = %109
%111 = load i64, i64* %4
%112 = add nsw i64 %111, 1
store i64 %112, i64* %4
br label %45
113: ; preds = %45
store i32 0, i32* %10
store i64 0, i64* %4
br label %114
114: ; preds = %131, %113
%115 = load i64, i64* %4
%116 = load i64, i64* %6
%117 = icmp slt i64 %115, %116
br i1 %117, label %118, label %134
118: ; preds = %114
%119 = load i64, i64* %4
%120 = getelementptr inbounds [1000 x i64], [1000 x i64]* %3, i64 0, i64 %119
%121 = load i64, i64* %120
%122 = load i32, i32* %10
%123 = sext i32 %122 to i64
%124 = icmp sgt i64 %121, %123
br i1 %124, label %125, label %130
125: ; preds = %118
%126 = load i64, i64* %4
%127 = getelementptr inbounds [1000 x i64], [1000 x i64]* %3, i64 0, i64 %126
%128 = load i64, i64* %127
%129 = trunc i64 %128 to i32
store i32 %129, i32* %10
br label %130
130: ; preds = %125, %118
br label %131
131: ; preds = %130
%132 = load i64, i64* %4
%133 = add nsw i64 %132, 1
store i64 %133, i64* %4
br label %114
134: ; preds = %114
%135 = load i64, i64* %9
%136 = icmp sgt i64 %135, 1
br i1 %136, label %137, label %139
137: ; preds = %134
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %139
139: ; preds = %137, %134
%140 = load i64, i64* %9
%141 = load i32, i32* %10
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.2, i64 0, i64 0), i64 %140, i32 %141)
store i64 0, i64* %6
%143 = load i64, i64* %9
%144 = add nsw i64 %143, 1
store i64 %144, i64* %9
br label %145
145: ; preds = %139
br label %146
146: ; preds = %145
br label %11
147: ; preds = %32, %11
ret i32 0
}

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