#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 abs(int);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mergesort(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *, ...);
int main() {
  int tc = 0;
  scanf("%d", &tc);
  while (tc--) {
    int t = 1;
    int x = 1;
    int i, j, k, l;
    int *n;
    scanf("%d%d", &t, &x);
    n = (int *)malloc(t * sizeof(int));
    for (i = 0; i < t; i++) {
      scanf("%d", n + i);
    }
    mergesort(n, 0, t - 1);
    int sum, sum1, sum2;
    sum = sum1 = sum2 = 0;
    for (i = 0; i < t; i++)
      sum = sum + n[i];
    for (i = 0; i < x; i++)
      sum1 = sum1 + n[i];
    for (i = t - 1; i > t - x - 1; i--)
      sum2 = sum2 + n[i];
    int sum11 = sum - sum1;
    int sum22 = sum - sum2;
    if (abs(sum1 - sum11) >= abs(sum2 - sum22))
      printf("%d\n", abs(sum1 - sum11));
    else
      printf("%d\n", abs(sum2 - sum22));
    free(n);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
lea    0xe85(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x8(%rbp)
cmp    $0x0,%eax
je     1354 <main+0x1f4>
movl   $0x1,-0xc(%rbp)
movl   $0x1,-0x10(%rbp)
lea    0xe4f(%rip),%rdi
lea    -0xc(%rbp),%rsi
lea    -0x10(%rbp),%rdx
mov    $0x0,%al
call   1070 <scanf@plt>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1211 <main+0xb1>
mov    -0x28(%rbp),%rsi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe06(%rip),%rdi
mov    $0x0,%al
call   1070 <scanf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11da <main+0x7a>
mov    -0x28(%rbp),%rdi
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1080 <mergesort@plt>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1269 <main+0x109>
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    123e <main+0xde>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    129b <main+0x13b>
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1270 <main+0x110>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    12d7 <main+0x177>
mov    -0x34(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    12a4 <main+0x144>
mov    -0x2c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%edi
sub    -0x38(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%edi
sub    -0x3c(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
cmp    %ecx,%eax
jl     132d <main+0x1cd>
mov    -0x30(%rbp),%edi
sub    -0x38(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,%esi
lea    0xce2(%rip),%rdi
call   1050 <printf@plt>
jmp    1346 <main+0x1e6>
mov    -0x34(%rbp),%edi
sub    -0x3c(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,%esi
lea    0xcc4(%rip),%rdi
call   1050 <printf@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
jmp    1188 <main+0x28>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movl   $0x0,0x10(%rsp)
lea    0xe95(%rip),%rdi
lea    0x10(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
subl   $0x1,0x10(%rsp)
jae    1191 <main+0x41>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x14(%rsp),%r12
lea    0xe65(%rip),%r15
lea    0xe61(%rip),%r13
jmp    11e2 <main+0x92>
cs nopw 0x0(%rax,%rax,1)
add    %ebp,%ebp
sub    %eax,%ebp
mov    %ebp,%ecx
neg    %ecx
cmovs  %ebp,%ecx
add    %edi,%edi
sub    %eax,%edi
mov    %edi,%esi
neg    %esi
cmovs  %edi,%esi
cmp    %esi,%ecx
cmovae %ecx,%esi
mov    %r13,%rdi
call   1040 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
subl   $0x1,0x10(%rsp)
jb     1180 <main+0x30>
movl   $0x1,0xc(%rsp)
movl   $0x1,0x14(%rsp)
lea    0xe07(%rip),%rdi
lea    0xc(%rsp),%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    0xc(%rsp),%edx
test   %edx,%edx
jle    124f <main+0xff>
mov    %r14,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rdx
add    $0x4,%rbp
cmp    %rdx,%rbx
jl     1230 <main+0xe0>
add    $0xffffffff,%edx
xor    %ebp,%ebp
mov    %r14,%rdi
xor    %esi,%esi
call   1070 <mergesort@plt>
mov    0xc(%rsp),%ecx
mov    $0x0,%eax
test   %ecx,%ecx
jle    139d <main+0x24d>
cmp    $0x8,%ecx
jae    1280 <main+0x130>
xor    %edx,%edx
xor    %eax,%eax
jmp    1390 <main+0x240>
nopl   (%rax)
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x18,%rsi
jae    12ae <main+0x15e>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    1331 <main+0x1e1>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%r14,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r14,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r14,%rsi,4),%xmm1
movdqu 0x30(%r14,%rsi,4),%xmm3
movdqu 0x40(%r14,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r14,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r14,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r14,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    12d0 <main+0x180>
test   %rax,%rax
je     136c <main+0x21c>
lea    (%r14,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rax
jne    1350 <main+0x200>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rcx,%rdx
je     139d <main+0x24d>
nopl   0x0(%rax,%rax,1)
add    (%r14,%rdx,4),%eax
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1390 <main+0x240>
mov    0x14(%rsp),%edx
test   %edx,%edx
jle    14dd <main+0x38d>
cmp    $0x8,%edx
jae    13c0 <main+0x270>
xor    %esi,%esi
xor    %ebp,%ebp
jmp    14d0 <main+0x380>
nopw   0x0(%rax,%rax,1)
mov    %edx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rbp
jae    13ee <main+0x29e>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    1471 <main+0x321>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
and    %rbp,%rdi
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%r14,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r14,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r14,%rbp,4),%xmm1
movdqu 0x30(%r14,%rbp,4),%xmm3
movdqu 0x40(%r14,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r14,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r14,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r14,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1410 <main+0x2c0>
test   %rbx,%rbx
je     14ac <main+0x35c>
lea    (%r14,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rdi,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rdi,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    1490 <main+0x340>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %rdx,%rsi
je     14dd <main+0x38d>
nopl   0x0(%rax,%rax,1)
add    (%r14,%rsi,4),%ebp
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    14d0 <main+0x380>
not    %edx
add    %ecx,%edx
add    $0xffffffff,%ecx
xor    %edi,%edi
cmp    %edx,%ecx
jle    11b0 <main+0x60>
movslq %ecx,%rcx
movslq %edx,%rdx
mov    %rcx,%r10
sub    %rdx,%r10
xor    %edi,%edi
cmp    $0x8,%r10
jb     15f0 <main+0x4a0>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1602 <main+0x4b2>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
lea    0x2(%rsi),%rdi
and    %r9,%rdi
lea    (%r14,%rcx,4),%rsi
add    $0xfffffffffffffff4,%rsi
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rbx,4),%xmm2
movdqu -0x20(%rsi,%rbx,4),%xmm3
movdqu -0x10(%rsi,%rbx,4),%xmm4
movdqu (%rsi,%rbx,4),%xmm5
pshufd $0x1b,%xmm5,%xmm5
paddd  %xmm0,%xmm5
pshufd $0x1b,%xmm4,%xmm4
paddd  %xmm1,%xmm4
pshufd $0x1b,%xmm3,%xmm0
paddd  %xmm5,%xmm0
pshufd $0x1b,%xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1550 <main+0x400>
neg    %rbx
test   $0x1,%r9b
je     15c4 <main+0x474>
mov    %rcx,%rsi
sub    %rbx,%rsi
movdqu -0x1c(%r14,%rsi,4),%xmm2
movdqu -0xc(%r14,%rsi,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
paddd  %xmm3,%xmm0
pshufd $0x1b,%xmm2,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
cmp    %r8,%r10
je     11b0 <main+0x60>
sub    %r8,%rcx
nopw   0x0(%rax,%rax,1)
add    (%r14,%rcx,4),%edi
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rcx
jg     15f0 <main+0x4a0>
jmp    11b0 <main+0x60>
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    159e <main+0x44e>
jmp    15c4 <main+0x474>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [5 x i8] c"%d%d\00"
@.str.2 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = bitcast i32* %1 to i8*
store i32 0, i32* %1
%5 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%6 = load i32, i32* %1
%7 = add nsw i32 %6, -1
store i32 %7, i32* %1
%8 = icmp eq i32 %6, 0
br i1 %8, label %337, label %9
9: ; preds = %0
%10 = bitcast i32* %2 to i8*
%11 = bitcast i32* %3 to i8*
br label %12
12: ; preds = %9, %322
store i32 1, i32* %2
store i32 1, i32* %3
%13 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32* %2, i32* %3)
%14 = load i32, i32* %2
%15 = shl i32 %14, 2
%16 = call i64 @malloc(i32 %15)
%17 = inttoptr i64 %16 to i32*
%18 = load i32, i32* %2
%19 = icmp sgt i32 %18, 0
br i1 %19, label %20, label %28
20: ; preds = %12, %20
%21 = phi i64 [ %24, %20 ], [ 0, %12 ]
%22 = getelementptr inbounds i32, i32* %17, i64 %21
%23 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %22)
%24 = add nuw nsw i64 %21, 1
%25 = load i32, i32* %2
%26 = sext i32 %25 to i64
%27 = icmp slt i64 %24, %26
br i1 %27, label %20, label %28
28: ; preds = %20, %12
%29 = phi i32 [ %18, %12 ], [ %25, %20 ]
%30 = add nsw i32 %29, -1
%31 = call i32 @mergesort(i32* %17, i32 0, i32 %30)
%32 = load i32, i32* %2
%33 = icmp sgt i32 %32, 0
br i1 %33, label %34, label %121
34: ; preds = %28
%35 = zext i32 %32 to i64
%36 = icmp ult i32 %32, 8
br i1 %36, label %118, label %37
37: ; preds = %34
%38 = and i64 %35, 4294967288
%39 = add nsw i64 %38, -8
%40 = lshr exact i64 %39, 3
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 3
%43 = icmp ult i64 %39, 24
br i1 %43, label %89, label %44
44: ; preds = %37
%45 = and i64 %41, 4611686018427387900
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %86, %46 ]
%48 = phi <4 x i32> [ zeroinitializer, %44 ], [ %84, %46 ]
%49 = phi <4 x i32> [ zeroinitializer, %44 ], [ %85, %46 ]
%50 = phi i64 [ 0, %44 ], [ %87, %46 ]
%51 = getelementptr inbounds i32, i32* %17, i64 %47
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = getelementptr inbounds i32, i32* %51, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
%56 = load <4 x i32>, <4 x i32>* %55
%57 = add <4 x i32> %53, %48
%58 = add <4 x i32> %56, %49
%59 = or i64 %47, 8
%60 = getelementptr inbounds i32, i32* %17, i64 %59
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = getelementptr inbounds i32, i32* %60, i64 4
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = add <4 x i32> %62, %57
%67 = add <4 x i32> %65, %58
%68 = or i64 %47, 16
%69 = getelementptr inbounds i32, i32* %17, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = getelementptr inbounds i32, i32* %69, i64 4
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = add <4 x i32> %71, %66
%76 = add <4 x i32> %74, %67
%77 = or i64 %47, 24
%78 = getelementptr inbounds i32, i32* %17, i64 %77
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = getelementptr inbounds i32, i32* %78, i64 4
%82 = bitcast i32* %81 to <4 x i32>*
%83 = load <4 x i32>, <4 x i32>* %82
%84 = add <4 x i32> %80, %75
%85 = add <4 x i32> %83, %76
%86 = add nuw i64 %47, 32
%87 = add i64 %50, 4
%88 = icmp eq i64 %87, %45
br i1 %88, label %89, label %46
89: ; preds = %46, %37
%90 = phi <4 x i32> [ undef, %37 ], [ %84, %46 ]
%91 = phi <4 x i32> [ undef, %37 ], [ %85, %46 ]
%92 = phi i64 [ 0, %37 ], [ %86, %46 ]
%93 = phi <4 x i32> [ zeroinitializer, %37 ], [ %84, %46 ]
%94 = phi <4 x i32> [ zeroinitializer, %37 ], [ %85, %46 ]
%95 = icmp eq i64 %42, 0
br i1 %95, label %112, label %96
96: ; preds = %89, %96
%97 = phi i64 [ %109, %96 ], [ %92, %89 ]
%98 = phi <4 x i32> [ %107, %96 ], [ %93, %89 ]
%99 = phi <4 x i32> [ %108, %96 ], [ %94, %89 ]
%100 = phi i64 [ %110, %96 ], [ 0, %89 ]
%101 = getelementptr inbounds i32, i32* %17, i64 %97
%102 = bitcast i32* %101 to <4 x i32>*
%103 = load <4 x i32>, <4 x i32>* %102
%104 = getelementptr inbounds i32, i32* %101, i64 4
%105 = bitcast i32* %104 to <4 x i32>*
%106 = load <4 x i32>, <4 x i32>* %105
%107 = add <4 x i32> %103, %98
%108 = add <4 x i32> %106, %99
%109 = add nuw i64 %97, 8
%110 = add i64 %100, 1
%111 = icmp eq i64 %110, %42
br i1 %111, label %112, label %96
112: ; preds = %96, %89
%113 = phi <4 x i32> [ %90, %89 ], [ %107, %96 ]
%114 = phi <4 x i32> [ %91, %89 ], [ %108, %96 ]
%115 = add <4 x i32> %114, %113
%116 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %115)
%117 = icmp eq i64 %38, %35
br i1 %117, label %121, label %118
118: ; preds = %34, %112
%119 = phi i64 [ 0, %34 ], [ %38, %112 ]
%120 = phi i32 [ 0, %34 ], [ %116, %112 ]
br label %212
121: ; preds = %212, %112, %28
%122 = phi i32 [ 0, %28 ], [ %116, %112 ], [ %217, %212 ]
%123 = load i32, i32* %3
%124 = icmp sgt i32 %123, 0
br i1 %124, label %125, label %220
125: ; preds = %121
%126 = zext i32 %123 to i64
%127 = icmp ult i32 %123, 8
br i1 %127, label %209, label %128
128: ; preds = %125
%129 = and i64 %126, 4294967288
%130 = add nsw i64 %129, -8
%131 = lshr exact i64 %130, 3
%132 = add nuw nsw i64 %131, 1
%133 = and i64 %132, 3
%134 = icmp ult i64 %130, 24
br i1 %134, label %180, label %135
135: ; preds = %128
%136 = and i64 %132, 4611686018427387900
br label %137
137: ; preds = %137, %135
%138 = phi i64 [ 0, %135 ], [ %177, %137 ]
%139 = phi <4 x i32> [ zeroinitializer, %135 ], [ %175, %137 ]
%140 = phi <4 x i32> [ zeroinitializer, %135 ], [ %176, %137 ]
%141 = phi i64 [ 0, %135 ], [ %178, %137 ]
%142 = getelementptr inbounds i32, i32* %17, i64 %138
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = getelementptr inbounds i32, i32* %142, i64 4
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = add <4 x i32> %144, %139
%149 = add <4 x i32> %147, %140
%150 = or i64 %138, 8
%151 = getelementptr inbounds i32, i32* %17, i64 %150
%152 = bitcast i32* %151 to <4 x i32>*
%153 = load <4 x i32>, <4 x i32>* %152
%154 = getelementptr inbounds i32, i32* %151, i64 4
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = add <4 x i32> %153, %148
%158 = add <4 x i32> %156, %149
%159 = or i64 %138, 16
%160 = getelementptr inbounds i32, i32* %17, i64 %159
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = getelementptr inbounds i32, i32* %160, i64 4
%164 = bitcast i32* %163 to <4 x i32>*
%165 = load <4 x i32>, <4 x i32>* %164
%166 = add <4 x i32> %162, %157
%167 = add <4 x i32> %165, %158
%168 = or i64 %138, 24
%169 = getelementptr inbounds i32, i32* %17, i64 %168
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = getelementptr inbounds i32, i32* %169, i64 4
%173 = bitcast i32* %172 to <4 x i32>*
%174 = load <4 x i32>, <4 x i32>* %173
%175 = add <4 x i32> %171, %166
%176 = add <4 x i32> %174, %167
%177 = add nuw i64 %138, 32
%178 = add i64 %141, 4
%179 = icmp eq i64 %178, %136
br i1 %179, label %180, label %137
180: ; preds = %137, %128
%181 = phi <4 x i32> [ undef, %128 ], [ %175, %137 ]
%182 = phi <4 x i32> [ undef, %128 ], [ %176, %137 ]
%183 = phi i64 [ 0, %128 ], [ %177, %137 ]
%184 = phi <4 x i32> [ zeroinitializer, %128 ], [ %175, %137 ]
%185 = phi <4 x i32> [ zeroinitializer, %128 ], [ %176, %137 ]
%186 = icmp eq i64 %133, 0
br i1 %186, label %203, label %187
187: ; preds = %180, %187
%188 = phi i64 [ %200, %187 ], [ %183, %180 ]
%189 = phi <4 x i32> [ %198, %187 ], [ %184, %180 ]
%190 = phi <4 x i32> [ %199, %187 ], [ %185, %180 ]
%191 = phi i64 [ %201, %187 ], [ 0, %180 ]
%192 = getelementptr inbounds i32, i32* %17, i64 %188
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = getelementptr inbounds i32, i32* %192, i64 4
%196 = bitcast i32* %195 to <4 x i32>*
%197 = load <4 x i32>, <4 x i32>* %196
%198 = add <4 x i32> %194, %189
%199 = add <4 x i32> %197, %190
%200 = add nuw i64 %188, 8
%201 = add i64 %191, 1
%202 = icmp eq i64 %201, %133
br i1 %202, label %203, label %187
203: ; preds = %187, %180
%204 = phi <4 x i32> [ %181, %180 ], [ %198, %187 ]
%205 = phi <4 x i32> [ %182, %180 ], [ %199, %187 ]
%206 = add <4 x i32> %205, %204
%207 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %206)
%208 = icmp eq i64 %129, %126
br i1 %208, label %220, label %209
209: ; preds = %125, %203
%210 = phi i64 [ 0, %125 ], [ %129, %203 ]
%211 = phi i32 [ 0, %125 ], [ %207, %203 ]
br label %306
212: ; preds = %118, %212
%213 = phi i64 [ %218, %212 ], [ %119, %118 ]
%214 = phi i32 [ %217, %212 ], [ %120, %118 ]
%215 = getelementptr inbounds i32, i32* %17, i64 %213
%216 = load i32, i32* %215
%217 = add nsw i32 %216, %214
%218 = add nuw nsw i64 %213, 1
%219 = icmp eq i64 %218, %35
br i1 %219, label %121, label %212
220: ; preds = %306, %203, %121
%221 = phi i32 [ 0, %121 ], [ %207, %203 ], [ %311, %306 ]
%222 = xor i32 %123, -1
%223 = add i32 %32, %222
%224 = add i32 %32, -1
%225 = icmp sgt i32 %224, %223
br i1 %225, label %226, label %322
226: ; preds = %220
%227 = sext i32 %224 to i64
%228 = sext i32 %223 to i64
%229 = sub nsw i64 %227, %228
%230 = icmp ult i64 %229, 8
br i1 %230, label %303, label %231
231: ; preds = %226
%232 = and i64 %229, -8
%233 = sub nsw i64 %227, %232
%234 = add nsw i64 %232, -8
%235 = lshr exact i64 %234, 3
%236 = add nuw nsw i64 %235, 1
%237 = and i64 %236, 1
%238 = icmp eq i64 %234, 0
br i1 %238, label %276, label %239
239: ; preds = %231
%240 = and i64 %236, 4611686018427387902
br label %241
241: ; preds = %241, %239
%242 = phi i64 [ 0, %239 ], [ %273, %241 ]
%243 = phi <4 x i32> [ zeroinitializer, %239 ], [ %271, %241 ]
%244 = phi <4 x i32> [ zeroinitializer, %239 ], [ %272, %241 ]
%245 = phi i64 [ 0, %239 ], [ %274, %241 ]
%246 = sub i64 %227, %242
%247 = getelementptr inbounds i32, i32* %17, i64 %246
%248 = getelementptr inbounds i32, i32* %247, i64 -3
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = shufflevector <4 x i32> %250, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%252 = getelementptr inbounds i32, i32* %247, i64 -4
%253 = getelementptr inbounds i32, i32* %252, i64 -3
%254 = bitcast i32* %253 to <4 x i32>*
%255 = load <4 x i32>, <4 x i32>* %254
%256 = shufflevector <4 x i32> %255, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%257 = add <4 x i32> %251, %243
%258 = add <4 x i32> %256, %244
%259 = or i64 %242, 8
%260 = sub i64 %227, %259
%261 = getelementptr inbounds i32, i32* %17, i64 %260
%262 = getelementptr inbounds i32, i32* %261, i64 -3
%263 = bitcast i32* %262 to <4 x i32>*
%264 = load <4 x i32>, <4 x i32>* %263
%265 = shufflevector <4 x i32> %264, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%266 = getelementptr inbounds i32, i32* %261, i64 -4
%267 = getelementptr inbounds i32, i32* %266, i64 -3
%268 = bitcast i32* %267 to <4 x i32>*
%269 = load <4 x i32>, <4 x i32>* %268
%270 = shufflevector <4 x i32> %269, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%271 = add <4 x i32> %265, %257
%272 = add <4 x i32> %270, %258
%273 = add nuw i64 %242, 16
%274 = add i64 %245, 2
%275 = icmp eq i64 %274, %240
br i1 %275, label %276, label %241
276: ; preds = %241, %231
%277 = phi <4 x i32> [ undef, %231 ], [ %271, %241 ]
%278 = phi <4 x i32> [ undef, %231 ], [ %272, %241 ]
%279 = phi i64 [ 0, %231 ], [ %273, %241 ]
%280 = phi <4 x i32> [ zeroinitializer, %231 ], [ %271, %241 ]
%281 = phi <4 x i32> [ zeroinitializer, %231 ], [ %272, %241 ]
%282 = icmp eq i64 %237, 0
br i1 %282, label %297, label %283
283: ; preds = %276
%284 = sub i64 %227, %279
%285 = getelementptr inbounds i32, i32* %17, i64 %284
%286 = getelementptr inbounds i32, i32* %285, i64 -3
%287 = bitcast i32* %286 to <4 x i32>*
%288 = load <4 x i32>, <4 x i32>* %287
%289 = shufflevector <4 x i32> %288, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%290 = getelementptr inbounds i32, i32* %285, i64 -4
%291 = getelementptr inbounds i32, i32* %290, i64 -3
%292 = bitcast i32* %291 to <4 x i32>*
%293 = load <4 x i32>, <4 x i32>* %292
%294 = shufflevector <4 x i32> %293, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%295 = add <4 x i32> %289, %280
%296 = add <4 x i32> %294, %281
br label %297
297: ; preds = %276, %283
%298 = phi <4 x i32> [ %277, %276 ], [ %295, %283 ]
%299 = phi <4 x i32> [ %278, %276 ], [ %296, %283 ]
%300 = add <4 x i32> %299, %298
%301 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %300)
%302 = icmp eq i64 %229, %232
br i1 %302, label %322, label %303
303: ; preds = %226, %297
%304 = phi i64 [ %227, %226 ], [ %233, %297 ]
%305 = phi i32 [ 0, %226 ], [ %301, %297 ]
br label %314
306: ; preds = %209, %306
%307 = phi i64 [ %312, %306 ], [ %210, %209 ]
%308 = phi i32 [ %311, %306 ], [ %211, %209 ]
%309 = getelementptr inbounds i32, i32* %17, i64 %307
%310 = load i32, i32* %309
%311 = add nsw i32 %310, %308
%312 = add nuw nsw i64 %307, 1
%313 = icmp eq i64 %312, %126
br i1 %313, label %220, label %306
314: ; preds = %303, %314
%315 = phi i64 [ %320, %314 ], [ %304, %303 ]
%316 = phi i32 [ %319, %314 ], [ %305, %303 ]
%317 = getelementptr inbounds i32, i32* %17, i64 %315
%318 = load i32, i32* %317
%319 = add nsw i32 %318, %316
%320 = add nsw i64 %315, -1
%321 = icmp sgt i64 %320, %228
br i1 %321, label %314, label %322
322: ; preds = %314, %297, %220
%323 = phi i32 [ 0, %220 ], [ %301, %297 ], [ %319, %314 ]
%324 = shl i32 %221, 1
%325 = sub i32 %324, %122
%326 = call i32 @llvm.abs.i32(i32 %325, i1 true)
%327 = shl i32 %323, 1
%328 = sub i32 %327, %122
%329 = call i32 @llvm.abs.i32(i32 %328, i1 true)
%330 = icmp ult i32 %326, %329
%331 = select i1 %330, i32 %329, i32 %326
%332 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %331)
%333 = call i32 @free(i32* %17)
%334 = load i32, i32* %1
%335 = add nsw i32 %334, -1
store i32 %335, i32* %1
%336 = icmp eq i32 %334, 0
br i1 %336, label %337, label %12
337: ; preds = %322, %0
ret i32 0
}