#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, int);
int /*<<< orphan*/ scanf(char *, int *, ...);
int main() {
  int s;
  int t;
  scanf("%d %d", &s, &t);
  int a;
  int b;
  scanf("%d %d", &a, &b);
  int m;
  int n;
  scanf("%d %d", &m, &n);
  int apple[m];
  for (int apple_i = 0; apple_i < m; apple_i++) {
    scanf("%d", &apple[apple_i]);
  }
  int orange[n];
  for (int orange_i = 0; orange_i < n; orange_i++) {
    scanf("%d", &orange[orange_i]);
  }
  int numOfApples = 0;
  int numOfOranges = 0;
  for (int i = 0; i < m; i++) {
    if ((a + apple[i]) >= s && (a + apple[i]) <= t) {
      numOfApples++;
    }
  }
  for (int i = 0; i < n; i++) {
    if ((b + orange[i]) >= s && (b + orange[i]) <= t) {
      numOfOranges++;
    }
  }
  printf("%d\n%d", numOfApples, numOfOranges);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
mov    %rdi,-0x70(%rbp)
xor    %eax,%eax
mov    %al,-0x61(%rbp)
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
call   1040 <scanf@plt>
mov    -0x70(%rbp),%rdi
mov    -0x61(%rbp),%al
lea    -0x10(%rbp),%rsi
lea    -0x14(%rbp),%rdx
call   1040 <scanf@plt>
mov    -0x70(%rbp),%rdi
mov    -0x61(%rbp),%al
lea    -0x18(%rbp),%rsi
lea    -0x1c(%rbp),%rdx
call   1040 <scanf@plt>
mov    -0x18(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11dc <main+0xbc>
mov    -0x60(%rbp),%rsi
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe42(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a5 <main+0x85>
mov    -0x1c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    123a <main+0x11a>
mov    -0x78(%rbp),%rsi
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xde4(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1203 <main+0xe3>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12a5 <main+0x185>
mov    -0x60(%rbp),%rcx
mov    -0x10(%rbp),%eax
movslq -0x50(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0x8(%rbp),%eax
jl     1292 <main+0x172>
mov    -0x60(%rbp),%rcx
mov    -0x10(%rbp),%eax
movslq -0x50(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0xc(%rbp),%eax
jg     1292 <main+0x172>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1297 <main+0x177>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    124f <main+0x12f>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1302 <main+0x1e2>
mov    -0x78(%rbp),%rcx
mov    -0x14(%rbp),%eax
movslq -0x54(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0x8(%rbp),%eax
jl     12ef <main+0x1cf>
mov    -0x78(%rbp),%rcx
mov    -0x14(%rbp),%eax
movslq -0x54(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0xc(%rbp),%eax
jg     12ef <main+0x1cf>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12f4 <main+0x1d4>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12ac <main+0x18c>
mov    -0x48(%rbp),%esi
mov    -0x4c(%rbp),%edx
lea    0xcf7(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
lea    0xec8(%rip),%rbx
lea    -0x38(%rbp),%rsi
lea    -0x34(%rbp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    -0x40(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    -0x2c(%rbp),%rsi
lea    -0x30(%rbp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    %rsp,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %rsp,%r13
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    -0x2c(%rbp),%ecx
test   %ecx,%ecx
jle    11be <main+0x9e>
lea    0xe71(%rip),%r14
mov    %r13,%r15
xor    %ebx,%ebx
nopl   (%rax)
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rcx
add    $0x4,%r15
cmp    %rcx,%rbx
jl     11a0 <main+0x80>
mov    -0x30(%rbp),%edi
mov    %rsp,%r12
lea    0xf(,%rdi,4),%rdx
and    $0xfffffffffffffff0,%rdx
sub    %rdx,%r12
mov    %r12,%rsp
test   %edi,%edi
jle    1211 <main+0xf1>
lea    0xe28(%rip),%r14
mov    %r12,%rbx
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
add    $0x1,%r15
movslq -0x30(%rbp),%rdi
add    $0x4,%rbx
cmp    %rdi,%r15
jl     11f0 <main+0xd0>
mov    -0x2c(%rbp),%ecx
xor    %edx,%edx
mov    $0x0,%esi
test   %ecx,%ecx
jle    1324 <main+0x204>
mov    -0x40(%rbp),%r8d
mov    -0x38(%rbp),%r9d
mov    -0x34(%rbp),%r10d
mov    %ecx,%r11d
cmp    $0x8,%ecx
jae    123d <main+0x11d>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1300 <main+0x1e0>
mov    %r11d,%ecx
and    $0xfffffff8,%ecx
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm9
movd   %r9d,%xmm1
pshufd $0x0,%xmm1,%xmm0
movd   %r10d,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    0x0(,%r11,4),%rsi
and    $0xffffffffffffffe0,%rsi
pxor   %xmm3,%xmm3
xor    %ebx,%ebx
pcmpeqd %xmm8,%xmm8
pxor   %xmm4,%xmm4
nopl   (%rax)
movdqa 0x0(%r13,%rbx,1),%xmm6
paddd  %xmm9,%xmm6
movdqa 0x10(%r13,%rbx,1),%xmm7
paddd  %xmm9,%xmm7
movdqa %xmm0,%xmm1
pcmpgtd %xmm6,%xmm1
pxor   %xmm8,%xmm1
movdqa %xmm0,%xmm5
pcmpgtd %xmm7,%xmm5
pxor   %xmm8,%xmm5
pcmpgtd %xmm2,%xmm6
pandn  %xmm1,%xmm6
psubd  %xmm6,%xmm3
pcmpgtd %xmm2,%xmm7
pandn  %xmm5,%xmm7
psubd  %xmm7,%xmm4
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1280 <main+0x160>
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
cmp    %r11,%rcx
je     1324 <main+0x204>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,4),%ebx
add    %r8d,%ebx
cmp    %r9d,%ebx
setge  %al
cmp    %r10d,%ebx
setle  %bl
and    %al,%bl
movzbl %bl,%eax
add    %eax,%esi
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1300 <main+0x1e0>
test   %edi,%edi
jle    1433 <main+0x313>
mov    -0x3c(%rbp),%r8d
mov    -0x38(%rbp),%r9d
mov    -0x34(%rbp),%r10d
mov    %edi,%r11d
cmp    $0x8,%edi
jae    1349 <main+0x229>
xor    %eax,%eax
xor    %edx,%edx
jmp    1410 <main+0x2f0>
mov    %r11d,%eax
and    $0xfffffff8,%eax
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm9
movd   %r9d,%xmm1
pshufd $0x0,%xmm1,%xmm0
movd   %r10d,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    0x0(,%r11,4),%rdx
and    $0xffffffffffffffe0,%rdx
pxor   %xmm3,%xmm3
xor    %edi,%edi
pcmpeqd %xmm8,%xmm8
pxor   %xmm4,%xmm4
nopl   0x0(%rax)
movdqa (%r12,%rdi,1),%xmm6
paddd  %xmm9,%xmm6
movdqa 0x10(%r12,%rdi,1),%xmm7
paddd  %xmm9,%xmm7
movdqa %xmm0,%xmm1
pcmpgtd %xmm6,%xmm1
pxor   %xmm8,%xmm1
movdqa %xmm0,%xmm5
pcmpgtd %xmm7,%xmm5
pxor   %xmm8,%xmm5
pcmpgtd %xmm2,%xmm6
pandn  %xmm1,%xmm6
psubd  %xmm6,%xmm3
pcmpgtd %xmm2,%xmm7
pandn  %xmm5,%xmm7
psubd  %xmm7,%xmm4
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1390 <main+0x270>
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
cmp    %r11,%rax
je     1433 <main+0x313>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rax,4),%edi
add    %r8d,%edi
cmp    %r9d,%edi
setge  %bl
cmp    %r10d,%edi
setle  %cl
and    %bl,%cl
movzbl %cl,%ecx
add    %ecx,%edx
add    $0x1,%rax
cmp    %rax,%r11
jne    1410 <main+0x2f0>
lea    0xbcc(%rip),%rdi
call   1030 <printf@plt>
mov    -0x48(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"%d %d\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [6 x i8] c"%d\0A%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i32
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i32 0, i32* %1
%17 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %2, i32* %3)
%18 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %4, i32* %5)
%19 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* %6, i32* %7)
%20 = load i32, i32* %6
%21 = zext i32 %20 to i64
%22 = call i8* @llvm.stacksave()
store i8* %22, i8** %8
%23 = alloca i32, i64 %21
store i64 %21, i64* %9
store i32 0, i32* %10
br label %24
24: ; preds = %33, %0
%25 = load i32, i32* %10
%26 = load i32, i32* %6
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %36
28: ; preds = %24
%29 = load i32, i32* %10
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %23, i64 %30
%32 = call i32 (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* %10
%35 = add nsw i32 %34, 1
store i32 %35, i32* %10
br label %24
36: ; preds = %24
%37 = load i32, i32* %7
%38 = zext i32 %37 to i64
%39 = alloca i32, i64 %38
store i64 %38, i64* %11
store i32 0, i32* %12
br label %40
40: ; preds = %49, %36
%41 = load i32, i32* %12
%42 = load i32, i32* %7
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %52
44: ; preds = %40
%45 = load i32, i32* %12
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %39, i64 %46
%48 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %47)
br label %49
49: ; preds = %44
%50 = load i32, i32* %12
%51 = add nsw i32 %50, 1
store i32 %51, i32* %12
br label %40
52: ; preds = %40
store i32 0, i32* %13
store i32 0, i32* %14
store i32 0, i32* %15
br label %53
53: ; preds = %79, %52
%54 = load i32, i32* %15
%55 = load i32, i32* %6
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %82
57: ; preds = %53
%58 = load i32, i32* %4
%59 = load i32, i32* %15
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %23, i64 %60
%62 = load i32, i32* %61
%63 = add nsw i32 %58, %62
%64 = load i32, i32* %2
%65 = icmp sge i32 %63, %64
br i1 %65, label %66, label %78
66: ; preds = %57
%67 = load i32, i32* %4
%68 = load i32, i32* %15
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %23, i64 %69
%71 = load i32, i32* %70
%72 = add nsw i32 %67, %71
%73 = load i32, i32* %3
%74 = icmp sle i32 %72, %73
br i1 %74, label %75, label %78
75: ; preds = %66
%76 = load i32, i32* %13
%77 = add nsw i32 %76, 1
store i32 %77, i32* %13
br label %78
78: ; preds = %75, %66, %57
br label %79
79: ; preds = %78
%80 = load i32, i32* %15
%81 = add nsw i32 %80, 1
store i32 %81, i32* %15
br label %53
82: ; preds = %53
store i32 0, i32* %16
br label %83
83: ; preds = %109, %82
%84 = load i32, i32* %16
%85 = load i32, i32* %7
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %112
87: ; preds = %83
%88 = load i32, i32* %5
%89 = load i32, i32* %16
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i32, i32* %39, i64 %90
%92 = load i32, i32* %91
%93 = add nsw i32 %88, %92
%94 = load i32, i32* %2
%95 = icmp sge i32 %93, %94
br i1 %95, label %96, label %108
96: ; preds = %87
%97 = load i32, i32* %5
%98 = load i32, i32* %16
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %39, i64 %99
%101 = load i32, i32* %100
%102 = add nsw i32 %97, %101
%103 = load i32, i32* %3
%104 = icmp sle i32 %102, %103
br i1 %104, label %105, label %108
105: ; preds = %96
%106 = load i32, i32* %14
%107 = add nsw i32 %106, 1
store i32 %107, i32* %14
br label %108
108: ; preds = %105, %96, %87
br label %109
109: ; preds = %108
%110 = load i32, i32* %16
%111 = add nsw i32 %110, 1
store i32 %111, i32* %16
br label %83
112: ; preds = %83
%113 = load i32, i32* %13
%114 = load i32, i32* %14
%115 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 %113, i32 %114)
store i32 0, i32* %1
%116 = load i8*, i8** %8
%117 = load i32, i32* %1
ret i32 %117
}

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