#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__ EOF;
int /*<<< orphan*/ printf(char *, int);
scalar_t__ scanf(char *, int *, ...);
int main(void) {
  int i, j, n, k, a[100001], sum[100001], max;
  while (scanf("%d %d", &n, &k) != EOF && (n != 0 || k != 0)) {
    max = -1000000000;
    for (i = 0; i < n; i++)
      scanf("%d", &a[i]);
    if (k == 1) {
      for (i = 0; i < n; i++) {
        if (a[i] > max)
          max = a[i];
      }
      printf("%d\n", max);
      continue;
    }
    for (i = 0; i < n - 1; i++) {
      sum[i] = a[i] + a[i + 1];
    }
    if (k == 2) {
      for (i = 0; i < n - 1; i++) {
        if (sum[i] > max)
          max = sum[i];
      }
      printf("%d\n", max);
      continue;
    }
    for (i = 0; i < k - 2; i++) {
      for (j = 0; j < n - 2 - i; j++) {
        sum[j] += a[j + i + 2];
      }
    }
    for (i = 0; i < n - k + 1; i++) {
      if (sum[i] > max)
        max = sum[i];
    }
    printf("%d\n", max);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc3540,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
lea    -0x10(%rbp),%rsi
lea    -0x14(%rbp),%rdx
mov    $0x0,%al
call   1040 <scanf@plt>
mov    %rax,%rcx
xor    %eax,%eax
mov    0x2e94(%rip),%rdx
cmp    (%rdx),%rcx
mov    %al,-0xc3535(%rbp)
je     118e <main+0x6e>
mov    $0x1,%al
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0xc3536(%rbp)
jne    1182 <main+0x62>
cmpl   $0x0,-0x14(%rbp)
setne  %al
mov    %al,-0xc3536(%rbp)
mov    -0xc3536(%rbp),%al
mov    %al,-0xc3535(%rbp)
mov    -0xc3535(%rbp),%al
test   $0x1,%al
jne    11a1 <main+0x81>
jmp    13ff <main+0x2df>
movl   $0xc4653600,-0xc3534(%rbp)
36 65 c4
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11ec <main+0xcc>
movslq -0x8(%rbp),%rax
lea    -0x61aa0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe2c(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11b2 <main+0x92>
cmpl   $0x1,-0x14(%rbp)
jne    125b <main+0x13b>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1244 <main+0x124>
movslq -0x8(%rbp),%rax
mov    -0x61aa0(%rbp,%rax,4),%eax
cmp    -0xc3534(%rbp),%eax
jle    1231 <main+0x111>
movslq -0x8(%rbp),%rax
mov    -0x61aa0(%rbp,%rax,4),%eax
mov    %eax,-0xc3534(%rbp)
jmp    1236 <main+0x116>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11fd <main+0xdd>
mov    -0xc3534(%rbp),%esi
lea    0xdb5(%rip),%rdi
call   1030 <printf@plt>
jmp    1132 <main+0x12>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12a6 <main+0x186>
movslq -0x8(%rbp),%rax
mov    -0x61aa0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
add    -0x61aa0(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0xc3530(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1262 <main+0x142>
cmpl   $0x2,-0x14(%rbp)
jne    131a <main+0x1fa>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1303 <main+0x1e3>
movslq -0x8(%rbp),%rax
mov    -0xc3530(%rbp,%rax,4),%eax
cmp    -0xc3534(%rbp),%eax
jle    12f0 <main+0x1d0>
movslq -0x8(%rbp),%rax
mov    -0xc3530(%rbp,%rax,4),%eax
mov    %eax,-0xc3534(%rbp)
jmp    12f5 <main+0x1d5>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12b7 <main+0x197>
mov    -0xc3534(%rbp),%esi
lea    0xcf6(%rip),%rdi
call   1030 <printf@plt>
jmp    1132 <main+0x12>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1392 <main+0x272>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
sub    -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    137f <main+0x25f>
mov    -0xc(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x61aa0(%rbp,%rax,4),%ecx
movslq -0xc(%rbp),%rax
add    -0xc3530(%rbp,%rax,4),%ecx
mov    %ecx,-0xc3530(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1339 <main+0x219>
jmp    1384 <main+0x264>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1321 <main+0x201>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13e8 <main+0x2c8>
movslq -0x8(%rbp),%rax
mov    -0xc3530(%rbp,%rax,4),%eax
cmp    -0xc3534(%rbp),%eax
jle    13d5 <main+0x2b5>
movslq -0x8(%rbp),%rax
mov    -0xc3530(%rbp,%rax,4),%eax
mov    %eax,-0xc3534(%rbp)
jmp    13da <main+0x2ba>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1399 <main+0x279>
mov    -0xc3534(%rbp),%esi
lea    0xc11(%rip),%rdi
call   1030 <printf@plt>
jmp    1132 <main+0x12>
xor    %eax,%eax
add    $0xc3540,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc3528,%rsp
lea    0xed8(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0x2e98(%rip),%r14
cmp    (%r14),%rax
jne    1169 <main+0x49>
xor    %eax,%eax
add    $0xc3528,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x61aa0(%rsp),%r12
lea    0xe9b(%rip),%r15
lea    0xe97(%rip),%r13
jmp    11b5 <main+0x95>
mov    $0xc4653600,%esi
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rdi
call   1030 <printf@plt>
lea    0xe71(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1040 <scanf@plt>
cmp    (%r14),%rax
je     1155 <main+0x35>
mov    0xc(%rsp),%eax
mov    0x8(%rsp),%r8d
mov    %eax,%ecx
or     %r8d,%ecx
je     1155 <main+0x35>
test   %eax,%eax
jle    11f4 <main+0xd4>
mov    %r12,%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %r15,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
add    $0x4,%rbp
cmp    %rax,%rbx
jl     11d0 <main+0xb0>
mov    0x8(%rsp),%r8d
cmp    $0x1,%r8d
jne    1220 <main+0x100>
test   %eax,%eax
jle    1181 <main+0x61>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1264 <main+0x144>
mov    $0xc4653600,%esi
xor    %eax,%eax
jmp    13c0 <main+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x2,%eax
jl     1250 <main+0x130>
lea    -0x1(%rax),%edi
mov    %edi,%ebx
mov    0x61aa0(%rsp),%esi
cmp    $0x8,%edi
jae    13da <main+0x2ba>
xor    %edx,%edx
jmp    14f0 <main+0x3d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0xc4653600,%esi
cmp    $0x2,%r8d
je     1190 <main+0x70>
jmp    1540 <main+0x420>
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1847 <main+0x727>
mov    %rdx,%rdi
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
and    %rsi,%rdi
xor    %esi,%esi
movdqa 0xd65(%rip),%xmm0
movdqa %xmm0,%xmm1
nop
movdqa 0x61aa0(%rsp,%rsi,4),%xmm2
movdqa 0x61ab0(%rsp,%rsi,4),%xmm3
movdqa 0x61ac0(%rsp,%rsi,4),%xmm4
movdqa 0x61ad0(%rsp,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm1,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm1,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm1
pcmpgtd %xmm6,%xmm1
pand   %xmm1,%xmm4
pandn  %xmm6,%xmm1
por    %xmm4,%xmm1
movdqa %xmm5,%xmm0
pcmpgtd %xmm2,%xmm0
pand   %xmm0,%xmm5
pandn  %xmm2,%xmm0
por    %xmm5,%xmm0
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12a0 <main+0x180>
test   $0x1,%dl
je     1365 <main+0x245>
movdqa 0x61aa0(%rsp,%rsi,4),%xmm2
movdqa 0x61ab0(%rsp,%rsi,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm1,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm1,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm1
movdqa %xmm2,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rcx,%rax
je     1190 <main+0x70>
nopl   0x0(%rax,%rax,1)
mov    0x61aa0(%rsp,%rax,4),%edx
cmp    %esi,%edx
cmovg  %edx,%esi
add    $0x1,%rax
cmp    %rax,%rcx
jne    13c0 <main+0x2a0>
jmp    1190 <main+0x70>
mov    %ebx,%edx
and    $0xfffffff8,%edx
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rsi,%rsi
je     1863 <main+0x743>
mov    %rcx,%rbp
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
and    %rsi,%rbp
xor    %esi,%esi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
movups 0x61aa4(%rsp,%rsi,4),%xmm2
movups 0x61ab4(%rsp,%rsi,4),%xmm3
movups 0x61ac4(%rsp,%rsi,4),%xmm4
movups 0x61ad4(%rsp,%rsi,4),%xmm0
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
paddd  %xmm2,%xmm1
shufps $0x3,%xmm3,%xmm2
shufps $0x98,%xmm3,%xmm2
paddd  %xmm3,%xmm2
movdqa %xmm1,0x10(%rsp,%rsi,4)
movdqa %xmm2,0x20(%rsp,%rsi,4)
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
paddd  %xmm4,%xmm3
shufps $0x3,%xmm0,%xmm4
shufps $0x98,%xmm0,%xmm4
paddd  %xmm0,%xmm4
movdqa %xmm3,0x30(%rsp,%rsi,4)
movdqa %xmm4,0x40(%rsp,%rsi,4)
add    $0x10,%rsi
movdqa %xmm0,%xmm1
add    $0xfffffffffffffffe,%rbp
jne    1420 <main+0x300>
test   $0x1,%cl
je     14de <main+0x3be>
lea    0x0(,%rsi,4),%rbp
or     $0x4,%rbp
movups 0x61aa0(%rsp,%rbp,1),%xmm1
movups 0x61ab0(%rsp,%rbp,1),%xmm2
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
paddd  %xmm1,%xmm0
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movdqa %xmm0,0x10(%rsp,%rsi,4)
movdqa %xmm1,0x20(%rsp,%rsi,4)
movaps %xmm2,%xmm0
cmp    %rbx,%rdx
je     150b <main+0x3eb>
pshufd $0xff,%xmm0,%xmm0
movd   %xmm0,%esi
nopl   0x0(%rax)
mov    0x61aa4(%rsp,%rdx,4),%ebp
add    %ebp,%esi
mov    %esi,0x10(%rsp,%rdx,4)
lea    0x1(%rdx),%rcx
mov    %ebp,%esi
mov    %rcx,%rdx
cmp    %rcx,%rbx
jne    14f0 <main+0x3d0>
cmp    $0x2,%r8d
jne    1540 <main+0x420>
mov    $0xc4653600,%esi
cmp    $0x2,%eax
jl     1190 <main+0x70>
cmp    $0x8,%edi
jae    1873 <main+0x753>
mov    $0xc4653600,%esi
xor    %eax,%eax
jmp    19c0 <main+0x8a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%r14
mov    %r12,%r13
cmp    $0x3,%r8d
jl     16b0 <main+0x590>
lea    -0x2(%r8),%r9d
lea    -0x2(%rax),%r10d
lea    0x61aa8(%rsp),%rdi
lea    0x61ad8(%rsp),%rbp
xor    %ebx,%ebx
mov    %r10d,%r12d
jmp    1589 <main+0x469>
nop
add    $0x1,%rbx
add    $0xffffffff,%r12d
add    $0x4,%rbp
add    $0x4,%rdi
cmp    %r9,%rbx
je     16b0 <main+0x590>
mov    %r12d,%r12d
mov    %r10d,%edx
sub    %ebx,%edx
test   %edx,%edx
jle    1570 <main+0x450>
cmp    $0x8,%edx
jae    15b0 <main+0x490>
xor    %ecx,%ecx
jmp    1690 <main+0x570>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%ecx
and    $0xfffffff8,%ecx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1644 <main+0x524>
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rbp,%rsi,4),%xmm0
movdqu -0x20(%rbp,%rsi,4),%xmm1
paddd  0x10(%rsp,%rsi,4),%xmm0
paddd  0x20(%rsp,%rsi,4),%xmm1
movdqa %xmm0,0x10(%rsp,%rsi,4)
movdqa %xmm1,0x20(%rsp,%rsi,4)
movdqu -0x10(%rbp,%rsi,4),%xmm0
movdqu 0x0(%rbp,%rsi,4),%xmm1
paddd  0x30(%rsp,%rsi,4),%xmm0
paddd  0x40(%rsp,%rsi,4),%xmm1
movdqa %xmm0,0x30(%rsp,%rsi,4)
movdqa %xmm1,0x40(%rsp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    15f0 <main+0x4d0>
jmp    1646 <main+0x526>
xor    %esi,%esi
mov    %edx,%ecx
and    $0xfffffff8,%ecx
test   $0x1,%r11b
je     1684 <main+0x564>
lea    0x2(%rbx),%r11
add    %rsi,%r11
movdqu 0x61aa0(%rsp,%r11,4),%xmm0
movdqu 0x61ab0(%rsp,%r11,4),%xmm1
paddd  0x10(%rsp,%rsi,4),%xmm0
paddd  0x20(%rsp,%rsi,4),%xmm1
movdqa %xmm0,0x10(%rsp,%rsi,4)
movdqa %xmm1,0x20(%rsp,%rsi,4)
cmp    %rdx,%rcx
je     1570 <main+0x450>
nopl   (%rax)
mov    (%rdi,%rcx,4),%edx
add    %edx,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1690 <main+0x570>
jmp    1570 <main+0x450>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xc4653600,%esi
sub    %r8d,%eax
mov    %r13,%r12
mov    %r14,%r13
mov    0x2923(%rip),%r14
jl     1190 <main+0x70>
add    $0x1,%eax
cmp    $0x8,%eax
jae    16df <main+0x5bf>
mov    $0xc4653600,%esi
xor    %ecx,%ecx
jmp    1830 <main+0x710>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     19d7 <main+0x8b7>
mov    %rdx,%rdi
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
and    %rsi,%rdi
xor    %esi,%esi
movdqa 0x8ea(%rip),%xmm0
movdqa %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movdqa 0x10(%rsp,%rsi,4),%xmm2
movdqa 0x20(%rsp,%rsi,4),%xmm3
movdqa 0x30(%rsp,%rsi,4),%xmm4
movdqa 0x40(%rsp,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm1,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm1,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm1
pcmpgtd %xmm6,%xmm1
pand   %xmm1,%xmm4
pandn  %xmm6,%xmm1
por    %xmm4,%xmm1
movdqa %xmm5,%xmm0
pcmpgtd %xmm2,%xmm0
pand   %xmm0,%xmm5
pandn  %xmm2,%xmm0
por    %xmm5,%xmm0
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1720 <main+0x600>
test   $0x1,%dl
je     17d3 <main+0x6b3>
movdqa 0x10(%rsp,%rsi,4),%xmm2
movdqa 0x20(%rsp,%rsi,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm1,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm1,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm1
movdqa %xmm2,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rax,%rcx
je     1190 <main+0x70>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp,%rcx,4),%edx
cmp    %esi,%edx
cmovg  %edx,%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1830 <main+0x710>
jmp    1190 <main+0x70>
xor    %esi,%esi
movdqa 0x7af(%rip),%xmm0
movdqa %xmm0,%xmm1
test   $0x1,%dl
jne    1323 <main+0x203>
jmp    1365 <main+0x245>
xor    %esi,%esi
test   $0x1,%cl
jne    149b <main+0x37b>
jmp    14de <main+0x3be>
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     19f3 <main+0x8d3>
mov    %rcx,%rdi
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%rdi
xor    %esi,%esi
movdqa 0x756(%rip),%xmm0
movdqa %xmm0,%xmm1
xchg   %ax,%ax
movdqa 0x10(%rsp,%rsi,4),%xmm2
movdqa 0x20(%rsp,%rsi,4),%xmm3
movdqa 0x30(%rsp,%rsi,4),%xmm4
movdqa 0x40(%rsp,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm1,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm1,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm1
pcmpgtd %xmm6,%xmm1
pand   %xmm1,%xmm4
pandn  %xmm6,%xmm1
por    %xmm4,%xmm1
movdqa %xmm5,%xmm0
pcmpgtd %xmm2,%xmm0
pand   %xmm0,%xmm5
pandn  %xmm2,%xmm0
por    %xmm5,%xmm0
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    18b0 <main+0x790>
test   $0x1,%cl
je     1963 <main+0x843>
movdqa 0x10(%rsp,%rsi,4),%xmm2
movdqa 0x20(%rsp,%rsi,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm1,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm1,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm1
movdqa %xmm2,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rbx,%rax
je     1190 <main+0x70>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp,%rax,4),%ecx
cmp    %esi,%ecx
cmovg  %ecx,%esi
add    $0x1,%rax
cmp    %rax,%rbx
jne    19c0 <main+0x8a0>
jmp    1190 <main+0x70>
xor    %esi,%esi
movdqa 0x61f(%rip),%xmm0
movdqa %xmm0,%xmm1
test   $0x1,%dl
jne    1797 <main+0x677>
jmp    17d3 <main+0x6b3>
xor    %esi,%esi
movdqa 0x603(%rip),%xmm0
movdqa %xmm0,%xmm1
test   $0x1,%cl
jne    1927 <main+0x807>
jmp    1963 <main+0x843>

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

LLVM IR (-O2):
@.str = [6 x i8] c"%d %d\00"
@EOF = global i64 0
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [100001 x i32]
%4 = alloca [100001 x i32]
%5 = bitcast i32* %1 to i8*
%6 = bitcast i32* %2 to i8*
%7 = bitcast [100001 x i32]* %3 to i8*
%8 = bitcast [100001 x i32]* %4 to i8*
%9 = call i64 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2)
%10 = load i64, i64* @EOF
%11 = icmp eq i64 %9, %10
br i1 %11, label %491, label %12
12: ; preds = %0
%13 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 0
br label %14
14: ; preds = %12, %199
%15 = load i32, i32* %1
%16 = icmp ne i32 %15, 0
%17 = load i32, i32* %2
%18 = icmp ne i32 %17, 0
%19 = select i1 %16, i1 true, i1 %18
br i1 %19, label %20, label %491
20: ; preds = %14
%21 = icmp sgt i32 %15, 0
br i1 %21, label %22, label %32
22: ; preds = %20, %22
%23 = phi i64 [ %26, %22 ], [ 0, %20 ]
%24 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %23
%25 = call i64 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %24)
%26 = add nuw nsw i64 %23, 1
%27 = load i32, i32* %1
%28 = sext i32 %27 to i64
%29 = icmp slt i64 %26, %28
br i1 %29, label %22, label %30
30: ; preds = %22
%31 = load i32, i32* %2
br label %32
32: ; preds = %30, %20
%33 = phi i32 [ %17, %20 ], [ %31, %30 ]
%34 = phi i32 [ %15, %20 ], [ %27, %30 ]
%35 = icmp eq i32 %33, 1
br i1 %35, label %119, label %36
36: ; preds = %32
%37 = add i32 %34, -1
%38 = icmp sgt i32 %34, 1
br i1 %38, label %39, label %216
39: ; preds = %36
%40 = zext i32 %37 to i64
%41 = load i32, i32* %13
%42 = icmp ult i32 %37, 8
br i1 %42, label %116, label %43
43: ; preds = %39
%44 = and i64 %40, 4294967288
%45 = insertelement <4 x i32> poison, i32 %41, i64 3
%46 = add nsw i64 %44, -8
%47 = lshr exact i64 %46, 3
%48 = add nuw nsw i64 %47, 1
%49 = and i64 %48, 1
%50 = icmp eq i64 %46, 0
br i1 %50, label %91, label %51
51: ; preds = %43
%52 = and i64 %48, 4611686018427387902
br label %53
53: ; preds = %53, %51
%54 = phi i64 [ 0, %51 ], [ %88, %53 ]
%55 = phi <4 x i32> [ %45, %51 ], [ %79, %53 ]
%56 = phi i64 [ 0, %51 ], [ %89, %53 ]
%57 = or i64 %54, 1
%58 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %57
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = getelementptr inbounds i32, i32* %58, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = shufflevector <4 x i32> %55, <4 x i32> %60, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%65 = shufflevector <4 x i32> %60, <4 x i32> %63, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%66 = add nsw <4 x i32> %60, %64
%67 = add nsw <4 x i32> %63, %65
%68 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %54
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %69
%70 = getelementptr inbounds i32, i32* %68, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %71
%72 = or i64 %54, 8
%73 = or i64 %54, 9
%74 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %73
%75 = bitcast i32* %74 to <4 x i32>*
%76 = load <4 x i32>, <4 x i32>* %75
%77 = getelementptr inbounds i32, i32* %74, i64 4
%78 = bitcast i32* %77 to <4 x i32>*
%79 = load <4 x i32>, <4 x i32>* %78
%80 = shufflevector <4 x i32> %63, <4 x i32> %76, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%81 = shufflevector <4 x i32> %76, <4 x i32> %79, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%82 = add nsw <4 x i32> %76, %80
%83 = add nsw <4 x i32> %79, %81
%84 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %72
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %85
%86 = getelementptr inbounds i32, i32* %84, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> %83, <4 x i32>* %87
%88 = add nuw i64 %54, 16
%89 = add i64 %56, 2
%90 = icmp eq i64 %89, %52
br i1 %90, label %91, label %53
91: ; preds = %53, %43
%92 = phi <4 x i32> [ undef, %43 ], [ %79, %53 ]
%93 = phi i64 [ 0, %43 ], [ %88, %53 ]
%94 = phi <4 x i32> [ %45, %43 ], [ %79, %53 ]
%95 = icmp eq i64 %49, 0
br i1 %95, label %112, label %96
96: ; preds = %91
%97 = or i64 %93, 1
%98 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, 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 = shufflevector <4 x i32> %94, <4 x i32> %100, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%105 = shufflevector <4 x i32> %100, <4 x i32> %103, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%106 = add nsw <4 x i32> %100, %104
%107 = add nsw <4 x i32> %103, %105
%108 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %93
%109 = bitcast i32* %108 to <4 x i32>*
store <4 x i32> %106, <4 x i32>* %109
%110 = getelementptr inbounds i32, i32* %108, i64 4
%111 = bitcast i32* %110 to <4 x i32>*
store <4 x i32> %107, <4 x i32>* %111
br label %112
112: ; preds = %91, %96
%113 = phi <4 x i32> [ %92, %91 ], [ %103, %96 ]
%114 = icmp eq i64 %44, %40
%115 = extractelement <4 x i32> %113, i64 3
br i1 %114, label %214, label %116
116: ; preds = %39, %112
%117 = phi i32 [ %115, %112 ], [ %41, %39 ]
%118 = phi i64 [ %44, %112 ], [ 0, %39 ]
br label %205
119: ; preds = %32
%120 = icmp sgt i32 %34, 0
br i1 %120, label %121, label %199
121: ; preds = %119
%122 = zext i32 %34 to i64
%123 = icmp ult i32 %34, 8
br i1 %123, label %187, label %124
124: ; preds = %121
%125 = and i64 %122, 4294967288
%126 = add nsw i64 %125, -8
%127 = lshr exact i64 %126, 3
%128 = add nuw nsw i64 %127, 1
%129 = and i64 %128, 1
%130 = icmp eq i64 %126, 0
br i1 %130, label %162, label %131
131: ; preds = %124
%132 = and i64 %128, 4611686018427387902
br label %133
133: ; preds = %133, %131
%134 = phi i64 [ 0, %131 ], [ %159, %133 ]
%135 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %131 ], [ %157, %133 ]
%136 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %131 ], [ %158, %133 ]
%137 = phi i64 [ 0, %131 ], [ %160, %133 ]
%138 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %134
%139 = bitcast i32* %138 to <4 x i32>*
%140 = load <4 x i32>, <4 x i32>* %139
%141 = getelementptr inbounds i32, i32* %138, i64 4
%142 = bitcast i32* %141 to <4 x i32>*
%143 = load <4 x i32>, <4 x i32>* %142
%144 = icmp sgt <4 x i32> %140, %135
%145 = icmp sgt <4 x i32> %143, %136
%146 = select <4 x i1> %144, <4 x i32> %140, <4 x i32> %135
%147 = select <4 x i1> %145, <4 x i32> %143, <4 x i32> %136
%148 = or i64 %134, 8
%149 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %148
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = getelementptr inbounds i32, i32* %149, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
%154 = load <4 x i32>, <4 x i32>* %153
%155 = icmp sgt <4 x i32> %151, %146
%156 = icmp sgt <4 x i32> %154, %147
%157 = select <4 x i1> %155, <4 x i32> %151, <4 x i32> %146
%158 = select <4 x i1> %156, <4 x i32> %154, <4 x i32> %147
%159 = add nuw i64 %134, 16
%160 = add i64 %137, 2
%161 = icmp eq i64 %160, %132
br i1 %161, label %162, label %133
162: ; preds = %133, %124
%163 = phi <4 x i32> [ undef, %124 ], [ %157, %133 ]
%164 = phi <4 x i32> [ undef, %124 ], [ %158, %133 ]
%165 = phi i64 [ 0, %124 ], [ %159, %133 ]
%166 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %124 ], [ %157, %133 ]
%167 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %124 ], [ %158, %133 ]
%168 = icmp eq i64 %129, 0
br i1 %168, label %180, label %169
169: ; preds = %162
%170 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %165
%171 = bitcast i32* %170 to <4 x i32>*
%172 = load <4 x i32>, <4 x i32>* %171
%173 = getelementptr inbounds i32, i32* %170, i64 4
%174 = bitcast i32* %173 to <4 x i32>*
%175 = load <4 x i32>, <4 x i32>* %174
%176 = icmp sgt <4 x i32> %172, %166
%177 = icmp sgt <4 x i32> %175, %167
%178 = select <4 x i1> %176, <4 x i32> %172, <4 x i32> %166
%179 = select <4 x i1> %177, <4 x i32> %175, <4 x i32> %167
br label %180
180: ; preds = %162, %169
%181 = phi <4 x i32> [ %163, %162 ], [ %178, %169 ]
%182 = phi <4 x i32> [ %164, %162 ], [ %179, %169 ]
%183 = icmp sgt <4 x i32> %181, %182
%184 = select <4 x i1> %183, <4 x i32> %181, <4 x i32> %182
%185 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %184)
%186 = icmp eq i64 %125, %122
br i1 %186, label %199, label %187
187: ; preds = %121, %180
%188 = phi i64 [ 0, %121 ], [ %125, %180 ]
%189 = phi i32 [ -1000000000, %121 ], [ %185, %180 ]
br label %190
190: ; preds = %187, %190
%191 = phi i64 [ %197, %190 ], [ %188, %187 ]
%192 = phi i32 [ %196, %190 ], [ %189, %187 ]
%193 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %191
%194 = load i32, i32* %193
%195 = icmp sgt i32 %194, %192
%196 = select i1 %195, i32 %194, i32 %192
%197 = add nuw nsw i64 %191, 1
%198 = icmp eq i64 %197, %122
br i1 %198, label %199, label %190
199: ; preds = %482, %294, %190, %366, %284, %180, %119, %303, %224, %216
%200 = phi i32 [ -1000000000, %224 ], [ -1000000000, %216 ], [ -1000000000, %303 ], [ -1000000000, %119 ], [ %185, %180 ], [ %289, %284 ], [ %371, %366 ], [ %196, %190 ], [ %300, %294 ], [ %488, %482 ]
%201 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %200)
%202 = call i64 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2)
%203 = load i64, i64* @EOF
%204 = icmp eq i64 %202, %203
br i1 %204, label %491, label %14
205: ; preds = %116, %205
%206 = phi i32 [ %210, %205 ], [ %117, %116 ]
%207 = phi i64 [ %208, %205 ], [ %118, %116 ]
%208 = add nuw nsw i64 %207, 1
%209 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %208
%210 = load i32, i32* %209
%211 = add nsw i32 %210, %206
%212 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %207
store i32 %211, i32* %212
%213 = icmp eq i64 %208, %40
br i1 %213, label %214, label %205
214: ; preds = %205, %112
%215 = icmp eq i32 %33, 2
br i1 %215, label %224, label %218
216: ; preds = %36
%217 = icmp eq i32 %33, 2
br i1 %217, label %199, label %218
218: ; preds = %216, %214
%219 = icmp sgt i32 %33, 2
br i1 %219, label %220, label %303
220: ; preds = %218
%221 = add nsw i32 %33, -2
%222 = add i32 %34, -2
%223 = zext i32 %221 to i64
br label %376
224: ; preds = %214
br i1 %38, label %225, label %199
225: ; preds = %224
%226 = zext i32 %37 to i64
%227 = icmp ult i32 %37, 8
br i1 %227, label %291, label %228
228: ; preds = %225
%229 = and i64 %40, 4294967288
%230 = add nsw i64 %229, -8
%231 = lshr exact i64 %230, 3
%232 = add nuw nsw i64 %231, 1
%233 = and i64 %232, 1
%234 = icmp eq i64 %230, 0
br i1 %234, label %266, label %235
235: ; preds = %228
%236 = and i64 %232, 4611686018427387902
br label %237
237: ; preds = %237, %235
%238 = phi i64 [ 0, %235 ], [ %263, %237 ]
%239 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %235 ], [ %261, %237 ]
%240 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %235 ], [ %262, %237 ]
%241 = phi i64 [ 0, %235 ], [ %264, %237 ]
%242 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %238
%243 = bitcast i32* %242 to <4 x i32>*
%244 = load <4 x i32>, <4 x i32>* %243
%245 = getelementptr inbounds i32, i32* %242, i64 4
%246 = bitcast i32* %245 to <4 x i32>*
%247 = load <4 x i32>, <4 x i32>* %246
%248 = icmp sgt <4 x i32> %244, %239
%249 = icmp sgt <4 x i32> %247, %240
%250 = select <4 x i1> %248, <4 x i32> %244, <4 x i32> %239
%251 = select <4 x i1> %249, <4 x i32> %247, <4 x i32> %240
%252 = or i64 %238, 8
%253 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %252
%254 = bitcast i32* %253 to <4 x i32>*
%255 = load <4 x i32>, <4 x i32>* %254
%256 = getelementptr inbounds i32, i32* %253, i64 4
%257 = bitcast i32* %256 to <4 x i32>*
%258 = load <4 x i32>, <4 x i32>* %257
%259 = icmp sgt <4 x i32> %255, %250
%260 = icmp sgt <4 x i32> %258, %251
%261 = select <4 x i1> %259, <4 x i32> %255, <4 x i32> %250
%262 = select <4 x i1> %260, <4 x i32> %258, <4 x i32> %251
%263 = add nuw i64 %238, 16
%264 = add i64 %241, 2
%265 = icmp eq i64 %264, %236
br i1 %265, label %266, label %237
266: ; preds = %237, %228
%267 = phi <4 x i32> [ undef, %228 ], [ %261, %237 ]
%268 = phi <4 x i32> [ undef, %228 ], [ %262, %237 ]
%269 = phi i64 [ 0, %228 ], [ %263, %237 ]
%270 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %228 ], [ %261, %237 ]
%271 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %228 ], [ %262, %237 ]
%272 = icmp eq i64 %233, 0
br i1 %272, label %284, label %273
273: ; preds = %266
%274 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %269
%275 = bitcast i32* %274 to <4 x i32>*
%276 = load <4 x i32>, <4 x i32>* %275
%277 = getelementptr inbounds i32, i32* %274, i64 4
%278 = bitcast i32* %277 to <4 x i32>*
%279 = load <4 x i32>, <4 x i32>* %278
%280 = icmp sgt <4 x i32> %276, %270
%281 = icmp sgt <4 x i32> %279, %271
%282 = select <4 x i1> %280, <4 x i32> %276, <4 x i32> %270
%283 = select <4 x i1> %281, <4 x i32> %279, <4 x i32> %271
br label %284
284: ; preds = %266, %273
%285 = phi <4 x i32> [ %267, %266 ], [ %282, %273 ]
%286 = phi <4 x i32> [ %268, %266 ], [ %283, %273 ]
%287 = icmp sgt <4 x i32> %285, %286
%288 = select <4 x i1> %287, <4 x i32> %285, <4 x i32> %286
%289 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %288)
%290 = icmp eq i64 %229, %40
br i1 %290, label %199, label %291
291: ; preds = %225, %284
%292 = phi i64 [ 0, %225 ], [ %229, %284 ]
%293 = phi i32 [ -1000000000, %225 ], [ %289, %284 ]
br label %294
294: ; preds = %291, %294
%295 = phi i64 [ %301, %294 ], [ %292, %291 ]
%296 = phi i32 [ %300, %294 ], [ %293, %291 ]
%297 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %295
%298 = load i32, i32* %297
%299 = icmp sgt i32 %298, %296
%300 = select i1 %299, i32 %298, i32 %296
%301 = add nuw nsw i64 %295, 1
%302 = icmp eq i64 %301, %226
br i1 %302, label %199, label %294
303: ; preds = %478, %218
%304 = icmp slt i32 %34, %33
br i1 %304, label %199, label %305
305: ; preds = %303
%306 = add i32 %34, 1
%307 = sub i32 %306, %33
%308 = zext i32 %307 to i64
%309 = icmp ult i32 %307, 8
br i1 %309, label %373, label %310
310: ; preds = %305
%311 = and i64 %308, 4294967288
%312 = add nsw i64 %311, -8
%313 = lshr exact i64 %312, 3
%314 = add nuw nsw i64 %313, 1
%315 = and i64 %314, 1
%316 = icmp eq i64 %312, 0
br i1 %316, label %348, label %317
317: ; preds = %310
%318 = and i64 %314, 4611686018427387902
br label %319
319: ; preds = %319, %317
%320 = phi i64 [ 0, %317 ], [ %345, %319 ]
%321 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %317 ], [ %343, %319 ]
%322 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %317 ], [ %344, %319 ]
%323 = phi i64 [ 0, %317 ], [ %346, %319 ]
%324 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %320
%325 = bitcast i32* %324 to <4 x i32>*
%326 = load <4 x i32>, <4 x i32>* %325
%327 = getelementptr inbounds i32, i32* %324, i64 4
%328 = bitcast i32* %327 to <4 x i32>*
%329 = load <4 x i32>, <4 x i32>* %328
%330 = icmp sgt <4 x i32> %326, %321
%331 = icmp sgt <4 x i32> %329, %322
%332 = select <4 x i1> %330, <4 x i32> %326, <4 x i32> %321
%333 = select <4 x i1> %331, <4 x i32> %329, <4 x i32> %322
%334 = or i64 %320, 8
%335 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %334
%336 = bitcast i32* %335 to <4 x i32>*
%337 = load <4 x i32>, <4 x i32>* %336
%338 = getelementptr inbounds i32, i32* %335, i64 4
%339 = bitcast i32* %338 to <4 x i32>*
%340 = load <4 x i32>, <4 x i32>* %339
%341 = icmp sgt <4 x i32> %337, %332
%342 = icmp sgt <4 x i32> %340, %333
%343 = select <4 x i1> %341, <4 x i32> %337, <4 x i32> %332
%344 = select <4 x i1> %342, <4 x i32> %340, <4 x i32> %333
%345 = add nuw i64 %320, 16
%346 = add i64 %323, 2
%347 = icmp eq i64 %346, %318
br i1 %347, label %348, label %319
348: ; preds = %319, %310
%349 = phi <4 x i32> [ undef, %310 ], [ %343, %319 ]
%350 = phi <4 x i32> [ undef, %310 ], [ %344, %319 ]
%351 = phi i64 [ 0, %310 ], [ %345, %319 ]
%352 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %310 ], [ %343, %319 ]
%353 = phi <4 x i32> [ <i32 -1000000000, i32 -1000000000, i32 -1000000000, i32 -1000000000>, %310 ], [ %344, %319 ]
%354 = icmp eq i64 %315, 0
br i1 %354, label %366, label %355
355: ; preds = %348
%356 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %351
%357 = bitcast i32* %356 to <4 x i32>*
%358 = load <4 x i32>, <4 x i32>* %357
%359 = getelementptr inbounds i32, i32* %356, i64 4
%360 = bitcast i32* %359 to <4 x i32>*
%361 = load <4 x i32>, <4 x i32>* %360
%362 = icmp sgt <4 x i32> %358, %352
%363 = icmp sgt <4 x i32> %361, %353
%364 = select <4 x i1> %362, <4 x i32> %358, <4 x i32> %352
%365 = select <4 x i1> %363, <4 x i32> %361, <4 x i32> %353
br label %366
366: ; preds = %348, %355
%367 = phi <4 x i32> [ %349, %348 ], [ %364, %355 ]
%368 = phi <4 x i32> [ %350, %348 ], [ %365, %355 ]
%369 = icmp sgt <4 x i32> %367, %368
%370 = select <4 x i1> %369, <4 x i32> %367, <4 x i32> %368
%371 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %370)
%372 = icmp eq i64 %311, %308
br i1 %372, label %199, label %373
373: ; preds = %305, %366
%374 = phi i64 [ 0, %305 ], [ %311, %366 ]
%375 = phi i32 [ -1000000000, %305 ], [ %371, %366 ]
br label %482
376: ; preds = %220, %478
%377 = phi i64 [ 0, %220 ], [ %479, %478 ]
%378 = phi i32 [ %222, %220 ], [ %480, %478 ]
%379 = trunc i64 %377 to i32
%380 = sub i32 %222, %379
%381 = and i32 %380, -8
%382 = zext i32 %381 to i64
%383 = add nsw i64 %382, -8
%384 = lshr exact i64 %383, 3
%385 = add nuw nsw i64 %384, 1
%386 = trunc i64 %377 to i32
%387 = sub i32 %222, %386
%388 = zext i32 %387 to i64
%389 = trunc i64 %377 to i32
%390 = sub i32 %222, %389
%391 = icmp sgt i32 %390, 0
br i1 %391, label %392, label %478
392: ; preds = %376
%393 = add nuw nsw i64 %377, 2
%394 = zext i32 %378 to i64
%395 = icmp ult i32 %387, 8
br i1 %395, label %466, label %396
396: ; preds = %392
%397 = and i64 %388, 4294967288
%398 = and i64 %385, 1
%399 = icmp eq i64 %383, 0
br i1 %399, label %443, label %400
400: ; preds = %396
%401 = and i64 %385, 4611686018427387902
br label %402
402: ; preds = %402, %400
%403 = phi i64 [ 0, %400 ], [ %440, %402 ]
%404 = phi i64 [ 0, %400 ], [ %441, %402 ]
%405 = add nuw nsw i64 %393, %403
%406 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %405
%407 = bitcast i32* %406 to <4 x i32>*
%408 = load <4 x i32>, <4 x i32>* %407
%409 = getelementptr inbounds i32, i32* %406, i64 4
%410 = bitcast i32* %409 to <4 x i32>*
%411 = load <4 x i32>, <4 x i32>* %410
%412 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %403
%413 = bitcast i32* %412 to <4 x i32>*
%414 = load <4 x i32>, <4 x i32>* %413
%415 = getelementptr inbounds i32, i32* %412, i64 4
%416 = bitcast i32* %415 to <4 x i32>*
%417 = load <4 x i32>, <4 x i32>* %416
%418 = add nsw <4 x i32> %414, %408
%419 = add nsw <4 x i32> %417, %411
%420 = bitcast i32* %412 to <4 x i32>*
store <4 x i32> %418, <4 x i32>* %420
%421 = bitcast i32* %415 to <4 x i32>*
store <4 x i32> %419, <4 x i32>* %421
%422 = or i64 %403, 8
%423 = add nuw nsw i64 %393, %422
%424 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %423
%425 = bitcast i32* %424 to <4 x i32>*
%426 = load <4 x i32>, <4 x i32>* %425
%427 = getelementptr inbounds i32, i32* %424, i64 4
%428 = bitcast i32* %427 to <4 x i32>*
%429 = load <4 x i32>, <4 x i32>* %428
%430 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %422
%431 = bitcast i32* %430 to <4 x i32>*
%432 = load <4 x i32>, <4 x i32>* %431
%433 = getelementptr inbounds i32, i32* %430, i64 4
%434 = bitcast i32* %433 to <4 x i32>*
%435 = load <4 x i32>, <4 x i32>* %434
%436 = add nsw <4 x i32> %432, %426
%437 = add nsw <4 x i32> %435, %429
%438 = bitcast i32* %430 to <4 x i32>*
store <4 x i32> %436, <4 x i32>* %438
%439 = bitcast i32* %433 to <4 x i32>*
store <4 x i32> %437, <4 x i32>* %439
%440 = add nuw i64 %403, 16
%441 = add i64 %404, 2
%442 = icmp eq i64 %441, %401
br i1 %442, label %443, label %402
443: ; preds = %402, %396
%444 = phi i64 [ 0, %396 ], [ %440, %402 ]
%445 = icmp eq i64 %398, 0
br i1 %445, label %464, label %446
446: ; preds = %443
%447 = add nuw nsw i64 %393, %444
%448 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %447
%449 = bitcast i32* %448 to <4 x i32>*
%450 = load <4 x i32>, <4 x i32>* %449
%451 = getelementptr inbounds i32, i32* %448, i64 4
%452 = bitcast i32* %451 to <4 x i32>*
%453 = load <4 x i32>, <4 x i32>* %452
%454 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %444
%455 = bitcast i32* %454 to <4 x i32>*
%456 = load <4 x i32>, <4 x i32>* %455
%457 = getelementptr inbounds i32, i32* %454, i64 4
%458 = bitcast i32* %457 to <4 x i32>*
%459 = load <4 x i32>, <4 x i32>* %458
%460 = add nsw <4 x i32> %456, %450
%461 = add nsw <4 x i32> %459, %453
%462 = bitcast i32* %454 to <4 x i32>*
store <4 x i32> %460, <4 x i32>* %462
%463 = bitcast i32* %457 to <4 x i32>*
store <4 x i32> %461, <4 x i32>* %463
br label %464
464: ; preds = %443, %446
%465 = icmp eq i64 %397, %388
br i1 %465, label %478, label %466
466: ; preds = %392, %464
%467 = phi i64 [ 0, %392 ], [ %397, %464 ]
br label %468
468: ; preds = %466, %468
%469 = phi i64 [ %476, %468 ], [ %467, %466 ]
%470 = add nuw nsw i64 %393, %469
%471 = getelementptr inbounds [100001 x i32], [100001 x i32]* %3, i64 0, i64 %470
%472 = load i32, i32* %471
%473 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %469
%474 = load i32, i32* %473
%475 = add nsw i32 %474, %472
store i32 %475, i32* %473
%476 = add nuw nsw i64 %469, 1
%477 = icmp eq i64 %476, %394
br i1 %477, label %478, label %468
478: ; preds = %468, %464, %376
%479 = add nuw nsw i64 %377, 1
%480 = add i32 %378, -1
%481 = icmp eq i64 %479, %223
br i1 %481, label %303, label %376
482: ; preds = %373, %482
%483 = phi i64 [ %489, %482 ], [ %374, %373 ]
%484 = phi i32 [ %488, %482 ], [ %375, %373 ]
%485 = getelementptr inbounds [100001 x i32], [100001 x i32]* %4, i64 0, i64 %483
%486 = load i32, i32* %485
%487 = icmp sgt i32 %486, %484
%488 = select i1 %487, i32 %486, i32 %484
%489 = add nuw nsw i64 %483, 1
%490 = icmp eq i64 %489, %308
br i1 %490, label %199, label %482
491: ; preds = %14, %199, %0
ret i32 0
}