#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*/ partition(int *, int, long);
int /*<<< orphan*/ printf(char *, long);
int /*<<< orphan*/ scanf(char *, long *, ...);
int main(void) {
  long int sum, f, c = 0, t, i, s, b;
  long int n;
  scanf("%ld", &t);
  while (t--) {
    scanf("%ld%ld", &n, &sum);
    int a[n + 1];
    c = 0;
    f = (n * (n + 1)) / 2;
    if (sum == n) {
      c = n - 1;
    } else if (sum == f) {
      c = 0;
    } else {
      c = 0;
      s = sum - n;
      for (i = 1; i <= n; i++)
        a[i] = 1;
      for (i = 2; i <= n; i++) {
        if (s <= i) {
          if (s == 0)
            break;
          a[i] = a[i] + 1;
          s--;
        } else {
          a[i] = a[i] + i;
          s = s - i;
        }
      }
      partition(a, 1, n);
    }
    for (i = 2; i <= n; i++) {
      if (a[i] != i)
        c++;
    }
    printf("%ld\n", c);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x20(%rbp)
lea    0xeb5(%rip),%rdi
lea    -0x28(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
cmp    $0x0,%rax
je     1377 <main+0x247>
lea    0xe87(%rip),%rdi
xor    %eax,%eax
lea    -0x48(%rbp),%rsi
lea    -0x10(%rbp),%rdx
call   1050 <scanf@plt>
mov    -0x48(%rbp),%rcx
mov    %rcx,%rax
add    $0x1,%rax
mov    %rsp,%rdx
mov    %rdx,-0x50(%rbp)
lea    0x13(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    $0x1,%rcx
imul   %rcx,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    11fc <main+0xcc>
mov    -0x48(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    130d <main+0x1dd>
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
jne    1217 <main+0xe7>
movq   $0x0,-0x20(%rbp)
jmp    1308 <main+0x1d8>
movq   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     1261 <main+0x131>
mov    -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1233 <main+0x103>
movq   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     12f6 <main+0x1c6>
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jg     12bb <main+0x18b>
cmpq   $0x0,-0x38(%rbp)
jne    1295 <main+0x165>
jmp    12f6 <main+0x1c6>
mov    -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    12e0 <main+0x1b0>
mov    -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rax,%rcx,4),%rcx
add    -0x30(%rbp),%rcx
mov    %ecx,%edx
mov    -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    12e5 <main+0x1b5>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1269 <main+0x139>
mov    -0x60(%rbp),%rdi
mov    -0x48(%rbp),%rdx
mov    $0x1,%esi
call   1030 <partition@plt>
jmp    130d <main+0x1dd>
movq   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     135b <main+0x22b>
mov    -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
cmp    -0x30(%rbp),%rax
je     1345 <main+0x215>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    134a <main+0x21a>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1315 <main+0x1e5>
mov    -0x20(%rbp),%rsi
lea    0xca1(%rip),%rdi
call   1040 <printf@plt>
mov    -0x50(%rbp),%rax
mov    %rax,%rsp
jmp    1159 <main+0x29>
xor    %eax,%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    $0x18,%rsp
lea    0xecb(%rip),%rdi
lea    -0x38(%rbp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
subq   $0x1,-0x38(%rbp)
jae    116b <main+0x3b>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe9e(%rip),%rbx
lea    -0x40(%rbp),%r12
lea    0xe9a(%rip),%r13
jmp    1192 <main+0x62>
nop
mov    %r13,%rdi
call   1040 <printf@plt>
mov    %r14,%rsp
subq   $0x1,-0x38(%rbp)
jb     115a <main+0x2a>
mov    %rbx,%rdi
lea    -0x30(%rbp),%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    %rsp,%r14
mov    -0x30(%rbp),%rax
mov    %rsp,%r15
lea    0x13(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    -0x30(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    %rax,%r9
sub    %rdx,%r9
jne    11e0 <main+0xb0>
lea    -0x1(%rdx),%rsi
cmp    $0x2,%rdx
jl     1180 <main+0x50>
jmp    12f8 <main+0x1c8>
xchg   %ax,%ax
lea    0x1(%rdx),%r8
mov    %r8,%rcx
imul   %rdx,%rcx
mov    %rcx,%rsi
shr    $0x3f,%rsi
add    %rcx,%rsi
sar    %rsi
cmp    %rsi,%rax
je     12ec <main+0x1bc>
test   %rdx,%rdx
movaps 0xdf5(%rip),%xmm0
jle    12db <main+0x1ab>
mov    $0x1,%esi
cmp    $0x8,%rdx
jb     12c0 <main+0x190>
mov    %rdx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x18,%rcx
jae    1245 <main+0x115>
xor    %ecx,%ecx
jmp    128a <main+0x15a>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups %xmm0,0x4(%r15,%rcx,4)
movups %xmm0,0x14(%r15,%rcx,4)
movups %xmm0,0x24(%r15,%rcx,4)
movups %xmm0,0x34(%r15,%rcx,4)
movups %xmm0,0x44(%r15,%rcx,4)
movups %xmm0,0x54(%r15,%rcx,4)
movups %xmm0,0x64(%r15,%rcx,4)
movups %xmm0,0x74(%r15,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1250 <main+0x120>
test   %rax,%rax
je     12b1 <main+0x181>
nop
lea    0x0(,%rcx,4),%rdi
or     $0x4,%rdi
movups %xmm0,(%r15,%rdi,1)
movups %xmm0,0x10(%r15,%rdi,1)
add    $0x8,%rcx
add    $0xffffffffffffffff,%rax
jne    1290 <main+0x160>
cmp    %rsi,%rdx
je     12d1 <main+0x1a1>
or     $0x1,%rsi
nopw   0x0(%rax,%rax,1)
movl   $0x1,(%r15,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    12c0 <main+0x190>
cmp    $0x2,%rdx
jge    13ae <main+0x27e>
mov    %r15,%rdi
mov    $0x1,%esi
call   1030 <partition@plt>
mov    -0x30(%rbp),%rdx
xor    %esi,%esi
cmp    $0x2,%rdx
jl     1180 <main+0x50>
lea    -0x1(%rdx),%r8
add    $0xfffffffffffffffe,%rdx
mov    %r8d,%r9d
and    $0x3,%r9d
mov    $0x2,%ecx
cmp    $0x3,%rdx
jb     1379 <main+0x249>
mov    %rbx,%r10
and    $0xfffffffffffffffc,%r8
mov    $0x2,%ecx
xchg   %ax,%ax
movslq (%r15,%rcx,4),%rdx
xor    %edi,%edi
cmp    %rdx,%rcx
setne  %dil
add    %rsi,%rdi
movslq 0x4(%r15,%rcx,4),%rdx
lea    0x1(%rcx),%rsi
xor    %ebx,%ebx
cmp    %rdx,%rsi
setne  %bl
add    %rdi,%rbx
movslq 0x8(%r15,%rcx,4),%rdx
lea    0x2(%rcx),%rdi
xor    %eax,%eax
cmp    %rdx,%rdi
setne  %al
add    %rbx,%rax
movslq 0xc(%r15,%rcx,4),%rdx
lea    0x3(%rcx),%rbx
xor    %esi,%esi
cmp    %rdx,%rbx
setne  %sil
add    %rax,%rsi
add    $0x4,%rcx
cmp    %r8,%rdi
jne    1320 <main+0x1f0>
mov    %r10,%rbx
test   %r9,%r9
je     1180 <main+0x50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%r15,%rcx,4),%rax
xor    %edx,%edx
cmp    %rax,%rcx
setne  %dl
add    %rdx,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%r9
jne    1390 <main+0x260>
jmp    1180 <main+0x50>
mov    $0x1,%ecx
sub    %rdx,%rcx
mov    $0x2,%esi
mov    $0xfffffffffffffffe,%rdi
jmp    13f1 <main+0x2c1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %esi,(%r15,%rsi,4)
add    %rdi,%r9
lea    (%rcx,%rsi,1),%rax
add    $0x1,%rax
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
cmp    $0x2,%rax
je     12db <main+0x1ab>
cmp    %rsi,%r9
jg     13d0 <main+0x2a0>
test   %r9,%r9
je     12db <main+0x1ab>
addl   $0x1,(%r15,%rsi,4)
add    $0xffffffffffffffff,%r9
jmp    13d7 <main+0x2a7>

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

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