int **threeSum(int *nums, int numsSize, int *returnSize) {
  int **buf = malloc(sizeof(int **) * 3000);
  int n = 0;
  __int128 tmp_lst[4000];
  int tmpn = 0;
  for (int i = 0; i < numsSize; ++i) {
    for (int j = i + 1; j < numsSize; ++j) {
      int rest = -(nums[i] + nums[j]);
      for (int k = j + 1; k < numsSize; ++k) {
        if (rest == nums[k]) {
          buf[n] = (int *)malloc(sizeof(int) * 3);
          buf[n][0] = nums[i];
          buf[n][1] = nums[j];
          buf[n][2] = rest;
          if (buf[n][1] < buf[n][0]) {
            buf[n][0] = nums[j];
            buf[n][1] = nums[i];
          }
          if (buf[n][2] < buf[n][0]) {
            buf[n][2] = buf[n][0];
            buf[n][0] = rest;
          }
          if (buf[n][2] < buf[n][1]) {
            int tmp = buf[n][2];
            buf[n][2] = buf[n][1];
            buf[n][1] = tmp;
          }
          int exist = 0;
          __int128 key = (buf[n][0] << 8) | (buf[n][1] << 4) | buf[n][2];
          for (int a = 0; a < tmpn; ++a) {
            if (tmp_lst[a] == key) {
              exist = 1;
              break;
            }
          }
          if (exist)
            continue;
          tmp_lst[tmpn++] = key;
          n++;
        }
      }
    }
  }
  *returnSize = n;
  return buf;
}


x86 assembly (clang, -O0):
<threeSum>:
push   %rbp
mov    %rsp,%rbp
sub    $0xfa70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    $0x5dc0,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0xfa34(%rbp)
movl   $0x0,-0xfa38(%rbp)
mov    -0xfa38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ad <threeSum+0x39d>
mov    -0xfa38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfa3c(%rbp)
mov    -0xfa3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1494 <threeSum+0x384>
mov    -0x8(%rbp),%rax
movslq -0xfa38(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
movslq -0xfa3c(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xfa40(%rbp)
mov    -0xfa3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfa44(%rbp)
mov    -0xfa44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    147b <threeSum+0x36b>
mov    -0xfa40(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xfa44(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1462 <threeSum+0x352>
mov    $0xc,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0xfa38(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0xfa3c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0xfa40(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jge    129d <threeSum+0x18d>
mov    -0x8(%rbp),%rax
movslq -0xfa3c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0xfa38(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jge    12f1 <threeSum+0x1e1>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0xfa40(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jge    135d <threeSum+0x24d>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    %eax,-0xfa48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0xfa48(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
movl   $0x0,-0xfa4c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx),%eax
mov    0x4(%rcx),%edx
shl    $0x8,%eax
shl    $0x4,%edx
or     %edx,%eax
mov    0x8(%rcx),%ecx
or     %ecx,%eax
movslq %eax,%rcx
mov    %rcx,%rax
sar    $0x3f,%rax
mov    %rcx,-0xfa60(%rbp)
mov    %rax,-0xfa58(%rbp)
movl   $0x0,-0xfa64(%rbp)
mov    -0xfa64(%rbp),%eax
cmp    -0xfa34(%rbp),%eax
jge    1413 <threeSum+0x303>
movslq -0xfa64(%rbp),%rax
shl    $0x4,%rax
movaps -0xfa30(%rbp,%rax,1),%xmm0
ff
movaps -0xfa60(%rbp),%xmm1
pcmpeqb %xmm1,%xmm0
pmovmskb %xmm0,%eax
sub    $0xffff,%eax
jne    13fa <threeSum+0x2ea>
jmp    13eb <threeSum+0x2db>
movl   $0x1,-0xfa4c(%rbp)
jmp    1413 <threeSum+0x303>
jmp    13ff <threeSum+0x2ef>
mov    -0xfa64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfa64(%rbp)
jmp    13a7 <threeSum+0x297>
cmpl   $0x0,-0xfa4c(%rbp)
je     1425 <threeSum+0x315>
jmp    1467 <threeSum+0x357>
mov    -0xfa60(%rbp),%rcx
mov    -0xfa58(%rbp),%rdx
movslq -0xfa34(%rbp),%rax
mov    %eax,%esi
add    $0x1,%esi
mov    %esi,-0xfa34(%rbp)
shl    $0x4,%rax
mov    %rdx,-0xfa28(%rbp,%rax,1)
ff
mov    %rcx,-0xfa30(%rbp,%rax,1)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1467 <threeSum+0x357>
mov    -0xfa44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfa44(%rbp)
jmp    11b1 <threeSum+0xa1>
jmp    1480 <threeSum+0x370>
mov    -0xfa3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfa3c(%rbp)
jmp    116d <threeSum+0x5d>
jmp    1499 <threeSum+0x389>
mov    -0xfa38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfa38(%rbp)
jmp    114f <threeSum+0x3f>
mov    -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
add    $0xfa70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<threeSum>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xfa58,%rsp
mov    %rdx,0x18(%rsp)
mov    %esi,%ebx
mov    %rdi,%r14
mov    $0x5dc0,%edi
call   1030 <malloc@plt>
mov    %rax,0x10(%rsp)
test   %ebx,%ebx
jle    12eb <threeSum+0x1db>
mov    %ebx,%ecx
mov    %ebx,%edx
xor    %eax,%eax
mov    $0x2,%edi
mov    $0x1,%ebp
xor    %r8d,%r8d
xor    %r13d,%r13d
mov    %r14,0x8(%rsp)
mov    %rdx,0x38(%rsp)
mov    %ebx,0x4(%rsp)
jmp    1190 <threeSum+0x80>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rdi
add    $0x1,%rdi
mov    0x20(%rsp),%rbp
add    $0x1,%rbp
mov    0x30(%rsp),%rax
cmp    %rdx,%rax
je     12ee <threeSum+0x1de>
lea    0x1(%rax),%rsi
mov    %rsi,0x30(%rsp)
cmp    %rdx,%rsi
mov    %rdi,0x28(%rsp)
mov    %rbp,0x20(%rsp)
jae    1170 <threeSum+0x60>
mov    (%r14,%rax,4),%r12d
mov    %rbp,%rax
mov    %rdi,%rbp
jmp    11d8 <threeSum+0xc8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rbp
add    $0x1,%rbp
mov    0x38(%rsp),%rdx
mov    0x48(%rsp),%rax
cmp    %rdx,%rax
je     1170 <threeSum+0x60>
lea    0x1(%rax),%rdx
mov    %rdx,0x48(%rsp)
cmp    %ecx,%edx
mov    %rbp,0x40(%rsp)
jge    11c0 <threeSum+0xb0>
mov    (%r14,%rax,4),%r15d
lea    (%r12,%r15,1),%ebx
neg    %ebx
jmp    1231 <threeSum+0x121>
cs nopw 0x0(%rax,%rax,1)
mov    %rax,%rcx
sar    $0x3f,%rcx
movslq %r13d,%rdx
add    $0x1,%r13d
shl    $0x4,%rdx
mov    %rcx,0x58(%rsp,%rdx,1)
mov    %rax,0x50(%rsp,%rdx,1)
add    $0x1,%r8d
mov    0x4(%rsp),%ecx
mov    0x8(%rsp),%r14
add    $0x1,%rbp
cmp    %ecx,%ebp
jge    11c0 <threeSum+0xb0>
cmp    %ebx,(%r14,%rbp,4)
jne    1229 <threeSum+0x119>
mov    $0xc,%edi
mov    %r8d,%r14d
call   1030 <malloc@plt>
mov    %r14d,%r8d
movslq %r14d,%rcx
mov    0x10(%rsp),%rdx
mov    %rax,(%rdx,%rcx,8)
mov    %r12d,(%rax)
mov    %r15d,0x4(%rax)
mov    %ebx,0x8(%rax)
mov    %r15d,%edx
mov    %r12d,%ecx
cmp    %r12d,%r15d
jge    1275 <threeSum+0x165>
mov    %r15d,(%rax)
mov    %r12d,0x4(%rax)
mov    %r12d,%edx
mov    %r15d,%ecx
cmp    %ebx,%ecx
jle    1290 <threeSum+0x180>
mov    %ecx,0x8(%rax)
mov    %ebx,(%rax)
mov    %ebx,%esi
cmp    %edx,%ecx
jl     1298 <threeSum+0x188>
mov    %ecx,%eax
mov    %edx,%ecx
jmp    12a0 <threeSum+0x190>
nopw   0x0(%rax,%rax,1)
mov    %ecx,%esi
mov    %ebx,%ecx
cmp    %edx,%ecx
jge    1284 <threeSum+0x174>
mov    %edx,0x8(%rax)
mov    %ecx,0x4(%rax)
mov    %edx,%eax
shl    $0x8,%esi
shl    $0x4,%ecx
or     %esi,%ecx
or     %eax,%ecx
movslq %ecx,%rax
test   %r13d,%r13d
jle    1200 <threeSum+0xf0>
mov    %r13d,%ecx
shl    $0x4,%rcx
xor    %edx,%edx
nop
mov    %rax,%rsi
sar    $0x3f,%rsi
mov    0x50(%rsp,%rdx,1),%rdi
xor    %rax,%rdi
xor    0x58(%rsp,%rdx,1),%rsi
or     %rdi,%rsi
je     1220 <threeSum+0x110>
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    12c0 <threeSum+0x1b0>
jmp    1200 <threeSum+0xf0>
xor    %r8d,%r8d
mov    0x18(%rsp),%rax
mov    %r8d,(%rax)
mov    0x10(%rsp),%rax
add    $0xfa58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32** @threeSum(i32* %0, i32 %1, i32* %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32**
%8 = alloca i32
%9 = alloca [4000 x i128]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i128
%18 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32* %2, i32** %6
%19 = call i8* @malloc(i64 24000)
%20 = bitcast i8* %19 to i32**
store i32** %20, i32*** %7
store i32 0, i32* %8
store i32 0, i32* %10
store i32 0, i32* %11
br label %21
21: ; preds = %278, %3
%22 = load i32, i32* %11
%23 = load i32, i32* %5
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %281
25: ; preds = %21
%26 = load i32, i32* %11
%27 = add nsw i32 %26, 1
store i32 %27, i32* %12
br label %28
28: ; preds = %274, %25
%29 = load i32, i32* %12
%30 = load i32, i32* %5
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %277
32: ; preds = %28
%33 = load i32*, i32** %4
%34 = load i32, i32* %11
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %33, i64 %35
%37 = load i32, i32* %36
%38 = load i32*, i32** %4
%39 = load i32, i32* %12
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i32, i32* %38, i64 %40
%42 = load i32, i32* %41
%43 = add nsw i32 %37, %42
%44 = sub nsw i32 0, %43
store i32 %44, i32* %13
%45 = load i32, i32* %12
%46 = add nsw i32 %45, 1
store i32 %46, i32* %14
br label %47
47: ; preds = %270, %32
%48 = load i32, i32* %14
%49 = load i32, i32* %5
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %273
51: ; preds = %47
%52 = load i32, i32* %13
%53 = load i32*, i32** %4
%54 = load i32, i32* %14
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %53, i64 %55
%57 = load i32, i32* %56
%58 = icmp eq i32 %52, %57
br i1 %58, label %59, label %269
59: ; preds = %51
%60 = call i8* @malloc(i64 12)
%61 = bitcast i8* %60 to i32*
%62 = load i32**, i32*** %7
%63 = load i32, i32* %8
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32*, i32** %62, i64 %64
store i32* %61, i32** %65
%66 = load i32*, i32** %4
%67 = load i32, i32* %11
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
%70 = load i32, i32* %69
%71 = load i32**, i32*** %7
%72 = load i32, i32* %8
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32*, i32** %71, i64 %73
%75 = load i32*, i32** %74
%76 = getelementptr inbounds i32, i32* %75, i64 0
store i32 %70, i32* %76
%77 = load i32*, i32** %4
%78 = load i32, i32* %12
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %80
%82 = load i32**, i32*** %7
%83 = load i32, i32* %8
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32*, i32** %82, i64 %84
%86 = load i32*, i32** %85
%87 = getelementptr inbounds i32, i32* %86, i64 1
store i32 %81, i32* %87
%88 = load i32, i32* %13
%89 = load i32**, i32*** %7
%90 = load i32, i32* %8
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32*, i32** %89, i64 %91
%93 = load i32*, i32** %92
%94 = getelementptr inbounds i32, i32* %93, i64 2
store i32 %88, i32* %94
%95 = load i32**, i32*** %7
%96 = load i32, i32* %8
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32*, i32** %95, i64 %97
%99 = load i32*, i32** %98
%100 = getelementptr inbounds i32, i32* %99, i64 1
%101 = load i32, i32* %100
%102 = load i32**, i32*** %7
%103 = load i32, i32* %8
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32*, i32** %102, i64 %104
%106 = load i32*, i32** %105
%107 = getelementptr inbounds i32, i32* %106, i64 0
%108 = load i32, i32* %107
%109 = icmp slt i32 %101, %108
br i1 %109, label %110, label %133
110: ; preds = %59
%111 = load i32*, i32** %4
%112 = load i32, i32* %12
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %111, i64 %113
%115 = load i32, i32* %114
%116 = load i32**, i32*** %7
%117 = load i32, i32* %8
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32*, i32** %116, i64 %118
%120 = load i32*, i32** %119
%121 = getelementptr inbounds i32, i32* %120, i64 0
store i32 %115, i32* %121
%122 = load i32*, i32** %4
%123 = load i32, i32* %11
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
%126 = load i32, i32* %125
%127 = load i32**, i32*** %7
%128 = load i32, i32* %8
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i32*, i32** %127, i64 %129
%131 = load i32*, i32** %130
%132 = getelementptr inbounds i32, i32* %131, i64 1
store i32 %126, i32* %132
br label %133
133: ; preds = %110, %59
%134 = load i32**, i32*** %7
%135 = load i32, i32* %8
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32*, i32** %134, i64 %136
%138 = load i32*, i32** %137
%139 = getelementptr inbounds i32, i32* %138, i64 2
%140 = load i32, i32* %139
%141 = load i32**, i32*** %7
%142 = load i32, i32* %8
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32*, i32** %141, i64 %143
%145 = load i32*, i32** %144
%146 = getelementptr inbounds i32, i32* %145, i64 0
%147 = load i32, i32* %146
%148 = icmp slt i32 %140, %147
br i1 %148, label %149, label %170
149: ; preds = %133
%150 = load i32**, i32*** %7
%151 = load i32, i32* %8
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32*, i32** %150, i64 %152
%154 = load i32*, i32** %153
%155 = getelementptr inbounds i32, i32* %154, i64 0
%156 = load i32, i32* %155
%157 = load i32**, i32*** %7
%158 = load i32, i32* %8
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32*, i32** %157, i64 %159
%161 = load i32*, i32** %160
%162 = getelementptr inbounds i32, i32* %161, i64 2
store i32 %156, i32* %162
%163 = load i32, i32* %13
%164 = load i32**, i32*** %7
%165 = load i32, i32* %8
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i32*, i32** %164, i64 %166
%168 = load i32*, i32** %167
%169 = getelementptr inbounds i32, i32* %168, i64 0
store i32 %163, i32* %169
br label %170
170: ; preds = %149, %133
%171 = load i32**, i32*** %7
%172 = load i32, i32* %8
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i32*, i32** %171, i64 %173
%175 = load i32*, i32** %174
%176 = getelementptr inbounds i32, i32* %175, i64 2
%177 = load i32, i32* %176
%178 = load i32**, i32*** %7
%179 = load i32, i32* %8
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32*, i32** %178, i64 %180
%182 = load i32*, i32** %181
%183 = getelementptr inbounds i32, i32* %182, i64 1
%184 = load i32, i32* %183
%185 = icmp slt i32 %177, %184
br i1 %185, label %186, label %214
186: ; preds = %170
%187 = load i32**, i32*** %7
%188 = load i32, i32* %8
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32*, i32** %187, i64 %189
%191 = load i32*, i32** %190
%192 = getelementptr inbounds i32, i32* %191, i64 2
%193 = load i32, i32* %192
store i32 %193, i32* %15
%194 = load i32**, i32*** %7
%195 = load i32, i32* %8
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i32*, i32** %194, i64 %196
%198 = load i32*, i32** %197
%199 = getelementptr inbounds i32, i32* %198, i64 1
%200 = load i32, i32* %199
%201 = load i32**, i32*** %7
%202 = load i32, i32* %8
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32*, i32** %201, i64 %203
%205 = load i32*, i32** %204
%206 = getelementptr inbounds i32, i32* %205, i64 2
store i32 %200, i32* %206
%207 = load i32, i32* %15
%208 = load i32**, i32*** %7
%209 = load i32, i32* %8
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32*, i32** %208, i64 %210
%212 = load i32*, i32** %211
%213 = getelementptr inbounds i32, i32* %212, i64 1
store i32 %207, i32* %213
br label %214
214: ; preds = %186, %170
store i32 0, i32* %16
%215 = load i32**, i32*** %7
%216 = load i32, i32* %8
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32*, i32** %215, i64 %217
%219 = load i32*, i32** %218
%220 = getelementptr inbounds i32, i32* %219, i64 0
%221 = load i32, i32* %220
%222 = shl i32 %221, 8
%223 = load i32**, i32*** %7
%224 = load i32, i32* %8
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i32*, i32** %223, i64 %225
%227 = load i32*, i32** %226
%228 = getelementptr inbounds i32, i32* %227, i64 1
%229 = load i32, i32* %228
%230 = shl i32 %229, 4
%231 = or i32 %222, %230
%232 = load i32**, i32*** %7
%233 = load i32, i32* %8
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32*, i32** %232, i64 %234
%236 = load i32*, i32** %235
%237 = getelementptr inbounds i32, i32* %236, i64 2
%238 = load i32, i32* %237
%239 = or i32 %231, %238
%240 = sext i32 %239 to i128
store i128 %240, i128* %17
store i32 0, i32* %18
br label %241
241: ; preds = %254, %214
%242 = load i32, i32* %18
%243 = load i32, i32* %10
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %257
245: ; preds = %241
%246 = load i32, i32* %18
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [4000 x i128], [4000 x i128]* %9, i64 0, i64 %247
%249 = load i128, i128* %248
%250 = load i128, i128* %17
%251 = icmp eq i128 %249, %250
br i1 %251, label %252, label %253
252: ; preds = %245
store i32 1, i32* %16
br label %257
253: ; preds = %245
br label %254
254: ; preds = %253
%255 = load i32, i32* %18
%256 = add nsw i32 %255, 1
store i32 %256, i32* %18
br label %241
257: ; preds = %252, %241
%258 = load i32, i32* %16
%259 = icmp ne i32 %258, 0
br i1 %259, label %260, label %261
260: ; preds = %257
br label %270
261: ; preds = %257
%262 = load i128, i128* %17
%263 = load i32, i32* %10
%264 = add nsw i32 %263, 1
store i32 %264, i32* %10
%265 = sext i32 %263 to i64
%266 = getelementptr inbounds [4000 x i128], [4000 x i128]* %9, i64 0, i64 %265
store i128 %262, i128* %266
%267 = load i32, i32* %8
%268 = add nsw i32 %267, 1
store i32 %268, i32* %8
br label %269
269: ; preds = %261, %51
br label %270
270: ; preds = %269, %260
%271 = load i32, i32* %14
%272 = add nsw i32 %271, 1
store i32 %272, i32* %14
br label %47
273: ; preds = %47
br label %274
274: ; preds = %273
%275 = load i32, i32* %12
%276 = add nsw i32 %275, 1
store i32 %276, i32* %12
br label %28
277: ; preds = %28
br label %278
278: ; preds = %277
%279 = load i32, i32* %11
%280 = add nsw i32 %279, 1
store i32 %280, i32* %11
br label %21
281: ; preds = %21
%282 = load i32, i32* %8
%283 = load i32*, i32** %6
store i32 %282, i32* %283
%284 = load i32**, i32*** %7
ret i32** %284
}

LLVM IR (-O2):
define noalias i32** @threeSum(i32* nocapture %0, i32 %1, i32* nocapture writeonly %2) {
%4 = alloca [4000 x i128]
%5 = tail call dereferenceable_or_null(24000) i8* @malloc(i64 24000)
%6 = bitcast i8* %5 to i32**
%7 = bitcast [4000 x i128]* %4 to i8*
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %18
9: ; preds = %3
%10 = zext i32 %1 to i64
%11 = zext i32 %1 to i64
br label %20
12: ; preds = %31, %20
%13 = phi i32 [ %25, %20 ], [ %32, %31 ]
%14 = phi i32 [ %24, %20 ], [ %33, %31 ]
%15 = add nuw nsw i64 %23, 1
%16 = add nuw nsw i64 %22, 1
%17 = icmp eq i64 %26, %11
br i1 %17, label %18, label %20
18: ; preds = %12, %3
%19 = phi i32 [ 0, %3 ], [ %14, %12 ]
store i32 %19, i32* %2
ret i32** %6
20: ; preds = %9, %12
%21 = phi i64 [ 0, %9 ], [ %26, %12 ]
%22 = phi i64 [ 1, %9 ], [ %16, %12 ]
%23 = phi i64 [ 2, %9 ], [ %15, %12 ]
%24 = phi i32 [ 0, %9 ], [ %14, %12 ]
%25 = phi i32 [ 0, %9 ], [ %13, %12 ]
%26 = add nuw nsw i64 %21, 1
%27 = icmp ult i64 %26, %10
br i1 %27, label %28, label %12
28: ; preds = %20
%29 = getelementptr inbounds i32, i32* %0, i64 %21
%30 = load i32, i32* %29
br label %36
31: ; preds = %100, %36
%32 = phi i32 [ %40, %36 ], [ %101, %100 ]
%33 = phi i32 [ %39, %36 ], [ %102, %100 ]
%34 = add nuw nsw i64 %38, 1
%35 = icmp eq i64 %45, %11
br i1 %35, label %12, label %36
36: ; preds = %28, %31
%37 = phi i64 [ %22, %28 ], [ %45, %31 ]
%38 = phi i64 [ %23, %28 ], [ %34, %31 ]
%39 = phi i32 [ %24, %28 ], [ %33, %31 ]
%40 = phi i32 [ %25, %28 ], [ %32, %31 ]
%41 = getelementptr inbounds i32, i32* %0, i64 %37
%42 = load i32, i32* %41
%43 = add nsw i32 %30, %42
%44 = sub nsw i32 0, %43
%45 = add nuw nsw i64 %37, 1
%46 = trunc i64 %45 to i32
%47 = icmp slt i32 %46, %1
br i1 %47, label %48, label %31
48: ; preds = %36
%49 = icmp slt i32 %42, %30
br label %50
50: ; preds = %48, %100
%51 = phi i64 [ %38, %48 ], [ %103, %100 ]
%52 = phi i32 [ %39, %48 ], [ %102, %100 ]
%53 = phi i32 [ %40, %48 ], [ %101, %100 ]
%54 = getelementptr inbounds i32, i32* %0, i64 %51
%55 = load i32, i32* %54
%56 = icmp eq i32 %55, %44
br i1 %56, label %57, label %100
57: ; preds = %50
%58 = tail call dereferenceable_or_null(12) i8* @malloc(i64 12)
%59 = bitcast i8* %58 to i32*
%60 = sext i32 %52 to i64
%61 = getelementptr inbounds i32*, i32** %6, i64 %60
%62 = bitcast i32** %61 to i8**
store i8* %58, i8** %62
store i32 %30, i32* %59
%63 = getelementptr inbounds i32, i32* %59, i64 1
store i32 %42, i32* %63
%64 = getelementptr inbounds i32, i32* %59, i64 2
store i32 %44, i32* %64
br i1 %49, label %65, label %66
65: ; preds = %57
store i32 %42, i32* %59
store i32 %30, i32* %63
br label %66
66: ; preds = %65, %57
%67 = phi i32 [ %30, %65 ], [ %42, %57 ]
%68 = phi i32 [ %42, %65 ], [ %30, %57 ]
%69 = icmp sgt i32 %68, %44
br i1 %69, label %70, label %71
70: ; preds = %66
store i32 %68, i32* %64
store i32 %44, i32* %59
br label %71
71: ; preds = %70, %66
%72 = phi i32 [ %44, %70 ], [ %68, %66 ]
%73 = phi i32 [ %68, %70 ], [ %44, %66 ]
%74 = icmp slt i32 %73, %67
br i1 %74, label %75, label %76
75: ; preds = %71
store i32 %67, i32* %64
store i32 %73, i32* %63
br label %76
76: ; preds = %75, %71
%77 = phi i32 [ %67, %75 ], [ %73, %71 ]
%78 = phi i32 [ %73, %75 ], [ %67, %71 ]
%79 = shl i32 %72, 8
%80 = shl i32 %78, 4
%81 = or i32 %80, %79
%82 = or i32 %81, %77
%83 = sext i32 %82 to i128
%84 = icmp sgt i32 %53, 0
br i1 %84, label %85, label %95
85: ; preds = %76
%86 = zext i32 %53 to i64
br label %89
87: ; preds = %89
%88 = icmp eq i64 %94, %86
br i1 %88, label %95, label %89
89: ; preds = %85, %87
%90 = phi i64 [ 0, %85 ], [ %94, %87 ]
%91 = getelementptr inbounds [4000 x i128], [4000 x i128]* %4, i64 0, i64 %90
%92 = load i128, i128* %91
%93 = icmp eq i128 %92, %83
%94 = add nuw nsw i64 %90, 1
br i1 %93, label %100, label %87
95: ; preds = %87, %76
%96 = add nsw i32 %53, 1
%97 = sext i32 %53 to i64
%98 = getelementptr inbounds [4000 x i128], [4000 x i128]* %4, i64 0, i64 %97
store i128 %83, i128* %98
%99 = add nsw i32 %52, 1
br label %100
100: ; preds = %89, %95, %50
%101 = phi i32 [ %53, %50 ], [ %96, %95 ], [ %53, %89 ]
%102 = phi i32 [ %52, %50 ], [ %99, %95 ], [ %52, %89 ]
%103 = add nuw nsw i64 %51, 1
%104 = trunc i64 %103 to i32
%105 = icmp slt i32 %104, %1
br i1 %105, label %50, label %31
}