#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 *, long long);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  long long int A[100000], K, largest = 0, new_largest = 0;
  long N, i;
  int z = 0;
  scanf("%ld %lld", &N, &K);
  for (i = 0; i < N; i++) {
    scanf("%lld", &A[i]);
    if (largest < A[i])
      largest = A[i];
  }
  if (K == 0) {
  } else if (K % 2 == 0) {
    for (i = 0; i < N; i++) {
      A[i] = largest - A[i];
      if (new_largest < A[i])
        new_largest = A[i];
    }
    largest = new_largest;
    for (i = 0; i < N; i++) {
      A[i] = largest - A[i];
    }
  } else {
    for (i = 0; i < N; i++) {
      A[i] = largest - A[i];
    }
  }
  for (i = 0; i < N; i++) {
    if (i == (N - 1)) {
      printf("%lld", A[i]);
    } else
      printf("%lld ", A[i]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc3540,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0xc3520(%rbp)
movq   $0x0,-0xc3528(%rbp)
movl   $0x0,-0xc353c(%rbp)
lea    0xea7(%rip),%rdi
lea    -0xc3530(%rbp),%rsi
lea    -0xc3518(%rbp),%rdx
mov    $0x0,%al
call   1040 <scanf@plt>
movq   $0x0,-0xc3538(%rbp)
mov    -0xc3538(%rbp),%rax
cmp    -0xc3530(%rbp),%rax
jge    11fe <main+0xde>
mov    -0xc3538(%rbp),%rax
lea    -0xc3510(%rbp),%rsi
shl    $0x3,%rax
add    %rax,%rsi
lea    0xe5b(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0xc3520(%rbp),%rax
mov    -0xc3538(%rbp),%rcx
cmp    -0xc3510(%rbp,%rcx,8),%rax
ff
jge    11e2 <main+0xc2>
mov    -0xc3538(%rbp),%rax
mov    -0xc3510(%rbp,%rax,8),%rax
ff
mov    %rax,-0xc3520(%rbp)
jmp    11e7 <main+0xc7>
mov    -0xc3538(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc3538(%rbp)
jmp    1179 <main+0x59>
cmpq   $0x0,-0xc3518(%rbp)
jne    1211 <main+0xf1>
jmp    1391 <main+0x271>
mov    -0xc3518(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    132c <main+0x20c>
movq   $0x0,-0xc3538(%rbp)
mov    -0xc3538(%rbp),%rax
cmp    -0xc3530(%rbp),%rax
jge    12be <main+0x19e>
mov    -0xc3520(%rbp),%rcx
mov    -0xc3538(%rbp),%rax
sub    -0xc3510(%rbp,%rax,8),%rcx
ff
mov    -0xc3538(%rbp),%rax
mov    %rcx,-0xc3510(%rbp,%rax,8)
ff
mov    -0xc3528(%rbp),%rax
mov    -0xc3538(%rbp),%rcx
cmp    -0xc3510(%rbp,%rcx,8),%rax
ff
jge    12a2 <main+0x182>
mov    -0xc3538(%rbp),%rax
mov    -0xc3510(%rbp,%rax,8),%rax
ff
mov    %rax,-0xc3528(%rbp)
jmp    12a7 <main+0x187>
mov    -0xc3538(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc3538(%rbp)
jmp    1237 <main+0x117>
mov    -0xc3528(%rbp),%rax
mov    %rax,-0xc3520(%rbp)
movq   $0x0,-0xc3538(%rbp)
mov    -0xc3538(%rbp),%rax
cmp    -0xc3530(%rbp),%rax
jge    1327 <main+0x207>
mov    -0xc3520(%rbp),%rcx
mov    -0xc3538(%rbp),%rax
sub    -0xc3510(%rbp,%rax,8),%rcx
mov    -0xc3538(%rbp),%rax
mov    %rcx,-0xc3510(%rbp,%rax,8)
ff
mov    -0xc3538(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc3538(%rbp)
jmp    12d7 <main+0x1b7>
jmp    138c <main+0x26c>
movq   $0x0,-0xc3538(%rbp)
mov    -0xc3538(%rbp),%rax
cmp    -0xc3530(%rbp),%rax
jge    1387 <main+0x267>
mov    -0xc3520(%rbp),%rcx
mov    -0xc3538(%rbp),%rax
sub    -0xc3510(%rbp,%rax,8),%rcx
ff
mov    -0xc3538(%rbp),%rax
mov    %rcx,-0xc3510(%rbp,%rax,8)
ff
mov    -0xc3538(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc3538(%rbp)
jmp    1337 <main+0x217>
jmp    138c <main+0x26c>
jmp    1391 <main+0x271>
movq   $0x0,-0xc3538(%rbp)
mov    -0xc3538(%rbp),%rax
cmp    -0xc3530(%rbp),%rax
jge    1422 <main+0x302>
mov    -0xc3538(%rbp),%rax
mov    -0xc3530(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jne    13eb <main+0x2cb>
mov    -0xc3538(%rbp),%rax
mov    -0xc3510(%rbp,%rax,8),%rsi
ff
lea    0xc23(%rip),%rdi
call   1030 <printf@plt>
jmp    1406 <main+0x2e6>
mov    -0xc3538(%rbp),%rax
mov    -0xc3510(%rbp,%rax,8),%rsi
ff
lea    0xc08(%rip),%rdi
call   1030 <printf@plt>
jmp    140b <main+0x2eb>
mov    -0xc3538(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc3538(%rbp)
jmp    139c <main+0x27c>
xor    %eax,%eax
add    $0xc3540,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0xc3518,%rsp
lea    0xecb(%rip),%rdi
xor    %r15d,%r15d
mov    %rsp,%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1040 <scanf@plt>
mov    (%rsp),%rax
test   %rax,%rax
jle    118f <main+0x6f>
lea    0xead(%rip),%r14
xor    %r12d,%r12d
xor    %r15d,%r15d
xor    %ebx,%ebx
nop
lea    (%rsp,%r12,1),%rsi
add    $0x10,%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0x10(%rsp,%rbx,8),%rax
cmp    %rax,%r15
cmovl  %rax,%r15
add    $0x1,%rbx
mov    (%rsp),%rax
add    $0x8,%r12
cmp    %rax,%rbx
jl     1160 <main+0x40>
mov    0x8(%rsp),%rcx
test   %rcx,%rcx
je     13d0 <main+0x2b0>
test   $0x1,%cl
jne    11b7 <main+0x97>
test   %rax,%rax
jle    1415 <main+0x2f5>
cmp    $0x1,%rax
jne    11cd <main+0xad>
xor    %edx,%edx
xor    %ecx,%ecx
jmp    1211 <main+0xf1>
test   %rax,%rax
jle    1415 <main+0x2f5>
cmp    $0x4,%rax
jae    1240 <main+0x120>
xor    %ecx,%ecx
jmp    13ba <main+0x29a>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
sub    0x10(%rsp,%rdx,8),%rdi
mov    %rdi,0x10(%rsp,%rdx,8)
cmp    %rdi,%rcx
cmovge %rcx,%rdi
mov    %r15,%rcx
sub    0x18(%rsp,%rdx,8),%rcx
mov    %rcx,0x18(%rsp,%rdx,8)
cmp    %rcx,%rdi
cmovge %rdi,%rcx
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    11e0 <main+0xc0>
test   $0x1,%al
je     1226 <main+0x106>
sub    0x10(%rsp,%rdx,8),%r15
mov    %r15,0x10(%rsp,%rdx,8)
cmp    %r15,%rcx
cmovl  %r15,%rcx
test   %rax,%rax
jle    1415 <main+0x2f5>
cmp    $0x4,%rax
jae    12d8 <main+0x1b8>
xor    %edx,%edx
jmp    142b <main+0x30b>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
movq   %r15,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1364 <main+0x244>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
psubq  0x10(%rsp,%rsi,8),%xmm1
movdqa %xmm0,%xmm2
psubq  0x20(%rsp,%rsi,8),%xmm2
movdqa %xmm1,0x10(%rsp,%rsi,8)
movdqa %xmm2,0x20(%rsp,%rsi,8)
movdqa %xmm0,%xmm1
psubq  0x30(%rsp,%rsi,8),%xmm1
movdqa %xmm0,%xmm2
psubq  0x40(%rsp,%rsi,8),%xmm2
movdqa %xmm1,0x30(%rsp,%rsi,8)
movdqa %xmm2,0x40(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1280 <main+0x160>
test   $0x1,%dl
jne    136b <main+0x24b>
jmp    13cb <main+0x2ab>
mov    %rax,%rdx
and    $0xfffffffffffffffc,%rdx
movq   %rcx,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     138d <main+0x26d>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
psubq  0x10(%rsp,%rdi,8),%xmm1
movdqa %xmm0,%xmm2
psubq  0x20(%rsp,%rdi,8),%xmm2
movdqa %xmm1,0x10(%rsp,%rdi,8)
movdqa %xmm2,0x20(%rsp,%rdi,8)
movdqa %xmm0,%xmm1
psubq  0x30(%rsp,%rdi,8),%xmm1
movdqa %xmm0,%xmm2
psubq  0x40(%rsp,%rdi,8),%xmm2
movdqa %xmm1,0x30(%rsp,%rdi,8)
movdqa %xmm2,0x40(%rsp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1310 <main+0x1f0>
test   $0x1,%bl
jne    1398 <main+0x278>
jmp    1426 <main+0x306>
xor    %esi,%esi
test   $0x1,%dl
je     13cb <main+0x2ab>
movdqa 0x10(%rsp,%rsi,8),%xmm1
movdqa %xmm0,%xmm2
psubq  %xmm1,%xmm2
psubq  0x20(%rsp,%rsi,8),%xmm0
movdqa %xmm2,0x10(%rsp,%rsi,8)
movdqa %xmm0,0x20(%rsp,%rsi,8)
jmp    13cb <main+0x2ab>
xor    %edi,%edi
test   $0x1,%bl
je     1426 <main+0x306>
movdqa 0x10(%rsp,%rdi,8),%xmm1
movdqa %xmm0,%xmm2
psubq  %xmm1,%xmm2
psubq  0x20(%rsp,%rdi,8),%xmm0
movdqa %xmm2,0x10(%rsp,%rdi,8)
movdqa %xmm0,0x20(%rsp,%rdi,8)
jmp    1426 <main+0x306>
mov    %r15,%rdx
sub    0x10(%rsp,%rcx,8),%rdx
mov    %rdx,0x10(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13ba <main+0x29a>
test   %rax,%rax
jle    1415 <main+0x2f5>
xor    %ebx,%ebx
lea    0xc26(%rip),%r14
lea    0xc24(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffffffffffff,%rax
cmp    %rax,%rbx
mov    0x10(%rsp,%rbx,8),%rsi
mov    %r15,%rdi
cmove  %r14,%rdi
call   1030 <printf@plt>
add    $0x1,%rbx
mov    (%rsp),%rax
cmp    %rax,%rbx
jl     13f0 <main+0x2d0>
xor    %eax,%eax
add    $0xc3518,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
cmp    %rdx,%rax
je     13d0 <main+0x2b0>
mov    %rcx,%rsi
sub    0x10(%rsp,%rdx,8),%rsi
mov    %rsi,0x10(%rsp,%rdx,8)
add    $0x1,%rdx
jmp    1426 <main+0x306>

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

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