#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__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, unsigned long long *);
int main() {
  unsigned long long n = 0, m = 0, max = 0, min = 0, i;
  unsigned long long *arrn, *arrm;
  unsigned long long addn[100] = {0}, addm[100] = {0};
  scanf("%llu", &n);
  arrn = (unsigned long long *)malloc(sizeof(unsigned long long) * n);
  for (i = 0; i < n; i++) {
    scanf("%llu", (arrn + i));
  }
  scanf("%llu", &m);
  arrm = (unsigned long long *)malloc(sizeof(unsigned long long) * m);
  for (i = 0; i < m; i++) {
    scanf("%llu", (arrm + i));
    if (arrm[i] > max) {
      max = arrm[i];
    }
  }
  for (i = 0; i < n; i++) {
    addn[max - arrn[i]] += 1;
  }
  for (i = 0; i < m; i++) {
    addm[max - arrm[i]] += 1;
  }
  for (i = 0; i < n; i++) {
    addm[i] = (addm[i] - addn[i]);
  }
  for (i = 99; i >= 0; i--) {
    if (addm[i] > 0) {
      printf("%llu ", max - i);
    }
  }
  printf("\b");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x680,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
lea    -0x360(%rbp),%rdi
xor    %esi,%esi
mov    $0x320,%edx
call   1040 <memset@plt>
lea    -0x680(%rbp),%rdi
xor    %esi,%esi
mov    $0x320,%edx
call   1040 <memset@plt>
lea    0xe61(%rip),%rdi
lea    -0x10(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11fd <main+0xbd>
mov    -0x38(%rbp),%rsi
mov    -0x30(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xe19(%rip),%rdi
call   1060 <scanf@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11c3 <main+0x83>
lea    0xdfc(%rip),%rdi
lea    -0x18(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    128d <main+0x14d>
mov    -0x40(%rbp),%rsi
mov    -0x30(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xdb4(%rip),%rdi
call   1060 <scanf@plt>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x20(%rbp),%rax
jbe    1277 <main+0x137>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
jmp    127c <main+0x13c>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1228 <main+0xe8>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    12d8 <main+0x198>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    -0x360(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x360(%rbp,%rax,8)
ff
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1295 <main+0x155>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1323 <main+0x1e3>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    -0x680(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x680(%rbp,%rax,8)
ff
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12e0 <main+0x1a0>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    136e <main+0x22e>
mov    -0x30(%rbp),%rax
mov    -0x680(%rbp,%rax,8),%rcx
ff
mov    -0x30(%rbp),%rax
sub    -0x360(%rbp,%rax,8),%rcx
ff
mov    -0x30(%rbp),%rax
mov    %rcx,-0x680(%rbp,%rax,8)
ff
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    132b <main+0x1eb>
movq   $0x63,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jb     13c0 <main+0x280>
mov    -0x30(%rbp),%rax
cmpq   $0x0,-0x680(%rbp,%rax,8)
jbe    13aa <main+0x26a>
mov    -0x20(%rbp),%rsi
sub    -0x30(%rbp),%rsi
lea    0xc62(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13af <main+0x26f>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1376 <main+0x236>
lea    0xc44(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x680,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x658,%rsp
movq   $0x0,(%rsp)
movq   $0x0,0x8(%rsp)
lea    0x330(%rsp),%rdi
mov    $0x320,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0x10(%rsp),%rdi
mov    $0x320,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xe72(%rip),%rdi
mov    %rsp,%rsi
call   1060 <scanf@plt>
mov    (%rsp),%edi
shl    $0x3,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
cmpq   $0x0,(%rsp)
je     11d9 <main+0x99>
xor    %ebp,%ebp
lea    0xe4c(%rip),%r15
mov    %r14,%rbx
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
add    $0x1,%rbp
add    $0x8,%rbx
cmp    (%rsp),%rbp
jb     11c0 <main+0x80>
lea    0xe20(%rip),%rdi
lea    0x8(%rsp),%rsi
call   1060 <scanf@plt>
mov    0x8(%rsp),%edi
shl    $0x3,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
cmpq   $0x0,0x8(%rsp)
je     123b <main+0xfb>
xor    %r13d,%r13d
lea    0xdf5(%rip),%r12
xor    %ebx,%ebx
xor    %ebp,%ebp
nop
lea    (%r15,%r13,1),%rsi
mov    %r12,%rdi
call   1060 <scanf@plt>
mov    (%r15,%rbp,8),%rax
cmp    %rbx,%rax
cmova  %rax,%rbx
add    $0x1,%rbp
mov    0x8(%rsp),%rcx
add    $0x8,%r13
cmp    %rcx,%rbp
jb     1210 <main+0xd0>
jmp    123f <main+0xff>
xor    %ebx,%ebx
xor    %ecx,%ecx
mov    (%rsp),%rax
test   %rax,%rax
je     129e <main+0x15e>
cmp    $0x1,%rax
jne    1252 <main+0x112>
xor    %edx,%edx
jmp    128a <main+0x14a>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
sub    (%r14,%rdx,8),%rdi
addq   $0x1,0x330(%rsp,%rdi,8)
mov    %rbx,%rdi
sub    0x8(%r14,%rdx,8),%rdi
addq   $0x1,0x330(%rsp,%rdi,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1260 <main+0x120>
test   $0x1,%al
je     129e <main+0x15e>
mov    %rbx,%rsi
sub    (%r14,%rdx,8),%rsi
addq   $0x1,0x330(%rsp,%rsi,8)
test   %rcx,%rcx
je     12f6 <main+0x1b6>
cmp    $0x1,%rcx
jne    12ad <main+0x16d>
xor    %edx,%edx
jmp    12e4 <main+0x1a4>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rdi
sub    (%r15,%rdx,8),%rdi
addq   $0x1,0x10(%rsp,%rdi,8)
mov    %rbx,%rdi
sub    0x8(%r15,%rdx,8),%rdi
addq   $0x1,0x10(%rsp,%rdi,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    12c0 <main+0x180>
test   $0x1,%cl
je     12f6 <main+0x1b6>
mov    %rbx,%rcx
sub    (%r15,%rdx,8),%rcx
addq   $0x1,0x10(%rsp,%rcx,8)
test   %rax,%rax
je     13e0 <main+0x2a0>
cmp    $0x4,%rax
jae    130c <main+0x1cc>
xor    %ecx,%ecx
jmp    13ca <main+0x28a>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1396 <main+0x256>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0x10(%rsp,%rdx,8),%xmm0
movdqa 0x20(%rsp,%rdx,8),%xmm1
movdqa 0x30(%rsp,%rdx,8),%xmm2
movdqa 0x40(%rsp,%rdx,8),%xmm3
psubq  0x330(%rsp,%rdx,8),%xmm0
psubq  0x340(%rsp,%rdx,8),%xmm1
movdqa %xmm0,0x10(%rsp,%rdx,8)
movdqa %xmm1,0x20(%rsp,%rdx,8)
psubq  0x350(%rsp,%rdx,8),%xmm2
psubq  0x360(%rsp,%rdx,8),%xmm3
movdqa %xmm2,0x30(%rsp,%rdx,8)
movdqa %xmm3,0x40(%rsp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1330 <main+0x1f0>
test   $0x1,%sil
jne    139e <main+0x25e>
jmp    13db <main+0x29b>
xor    %edx,%edx
test   $0x1,%sil
je     13db <main+0x29b>
movdqa 0x10(%rsp,%rdx,8),%xmm0
movdqa 0x20(%rsp,%rdx,8),%xmm1
psubq  0x330(%rsp,%rdx,8),%xmm0
psubq  0x340(%rsp,%rdx,8),%xmm1
movdqa %xmm0,0x10(%rsp,%rdx,8)
movdqa %xmm1,0x20(%rsp,%rdx,8)
jmp    13db <main+0x29b>
mov    0x330(%rsp,%rcx,8),%rdx
sub    %rdx,0x10(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13ca <main+0x28a>
add    $0xffffffffffffff9d,%rbx
lea    0x328(%rsp),%rbp
lea    0xc12(%rip),%r14
jmp    1408 <main+0x2c8>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0xfffffffffffffff8,%rbp
cmpq   $0x0,0x0(%rbp)
je     1400 <main+0x2c0>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1030 <printf@plt>
jmp    1400 <main+0x2c0>

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

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