#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
scalar_t__ malloc(unsigned long);
scalar_t__ realloc(unsigned long *, unsigned long);
int /*<<< orphan*/ stderr;
unsigned long *createChunkListGSS(unsigned long n, unsigned long N,
                                  unsigned long minsize, unsigned long *len,
                                  int gss) {
  unsigned long length, i, chunk, totalSize;
  unsigned long *chunkList, *chunkMlist;
  length = 0;
  i = 0;
  totalSize = n;
  chunkList = NULL;
  if (gss)
    n = n / 2;
  while (n > 0) {
    length++;
    if ((chunkList = (unsigned long *)realloc(
             chunkList, length * sizeof(unsigned long))) == NULL) {
      fprintf(stderr, "reallocating memory in createChunkListGSS function\n");
      exit(-1);
    }
    chunk = n / N;
    if (chunk < minsize) {
      if (n >= minsize) {
        chunk = minsize;
      } else {
        chunk = n;
      }
    }
    n = n - chunk;
    i = length - 1;
    chunkList[i] = chunk;
  }
  i = length - 1;
  if (chunkList[i] < minsize) {
    chunkList[0] += chunkList[length - 1];
    length--;
  }
  if (gss) {
    chunk = 0;
    chunkMlist = (unsigned long *)malloc(length * 2 * sizeof(unsigned long));
    for (i = (length - 1); i >= 0; i--) {
      chunkMlist[length - i - 1] = chunkList[i];
      chunkMlist[length + i] = chunkList[i];
      chunk += chunkList[i] * 2;
    }
    if (chunk < totalSize) {
      chunkMlist[length] += totalSize - chunk;
    }
    length *= 2;
    *len = length;
    return chunkMlist;
  }
  *len = length;
  return chunkList;
}


x86 assembly (clang, -O0):
<createChunkListGSS>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1192 <createChunkListGSS+0x52>
mov    -0x10(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1197 <createChunkListGSS+0x57>
cmpq   $0x0,-0x10(%rbp)
jbe    125f <createChunkListGSS+0x11f>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x38(%rbp),%rsi
shl    $0x3,%rsi
call   1050 <realloc@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    11ec <createChunkListGSS+0xac>
mov    0x2e0c(%rip),%rax
mov    (%rax),%edi
lea    0xe23(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>
mov    -0x10(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x18(%rbp)
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1232 <createChunkListGSS+0xf2>
mov    -0x10(%rbp),%rax
cmp    -0x20(%rbp),%rax
jb     1225 <createChunkListGSS+0xe5>
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    122d <createChunkListGSS+0xed>
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1232 <createChunkListGSS+0xf2>
mov    -0x10(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rdx
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1197 <createChunkListGSS+0x57>
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x20(%rbp),%rax
jae    12a7 <createChunkListGSS+0x167>
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x58(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1394 <createChunkListGSS+0x254>
movq   $0x0,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
shl    $0x1,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jb     134a <createChunkListGSS+0x20a>
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    -0x40(%rbp),%rcx
sub    $0x1,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x1,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    12da <createChunkListGSS+0x19a>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1370 <createChunkListGSS+0x230>
mov    -0x50(%rbp),%rdx
sub    -0x48(%rbp),%rdx
mov    -0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x60(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    13a7 <createChunkListGSS+0x267>
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x58(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<createChunkListGSS>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,0x10(%rsp)
mov    %rdi,%rbp
mov    %r8d,0xc(%rsp)
test   %r8d,%r8d
setne  %cl
shr    %cl,%rbp
mov    %rdx,%r12
mov    %rsi,%r13
xor    %ebx,%ebx
xor    %r15d,%r15d
jmp    11a6 <createChunkListGSS+0x66>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rax
xor    %edx,%edx
div    %r13
lea    0x1(%r14),%r15
cmp    %r12,%rbp
mov    %r12,%rcx
cmovb  %rbp,%rcx
cmp    %r12,%rax
cmovae %rax,%rcx
mov    %rcx,(%rbx,%r14,8)
sub    %rcx,%rbp
je     11da <createChunkListGSS+0x9a>
mov    %r15,%r14
lea    0x8(,%r15,8),%rsi
mov    %rbx,%rdi
call   1050 <realloc@plt>
test   %rax,%rax
je     1244 <createChunkListGSS+0x104>
mov    %rax,%rbx
mov    %rbp,%rax
or     %r13,%rax
shr    $0x20,%rax
jne    1180 <createChunkListGSS+0x40>
mov    %ebp,%eax
xor    %edx,%edx
div    %r13d
jmp    1188 <createChunkListGSS+0x48>
cmp    %r12,%rcx
jae    11e5 <createChunkListGSS+0xa5>
add    %rcx,(%rbx)
mov    %r14,%r15
cmpl   $0x0,0xc(%rsp)
je     122a <createChunkListGSS+0xea>
mov    %r15,%rbp
shl    $0x4,%rbp
mov    %rbp,%rdi
call   1040 <malloc@plt>
lea    (%rbx,%r15,8),%rcx
add    %rax,%rbp
mov    $0xfffffffffffffff8,%rdx
nopl   0x0(%rax)
mov    (%rcx,%rdx,1),%rsi
mov    %rsi,(%rax)
mov    (%rcx,%rdx,1),%rsi
mov    %rsi,0x0(%rbp,%rdx,1)
add    $0x8,%rax
add    $0xfffffffffffffff8,%rdx
jmp    1210 <createChunkListGSS+0xd0>
mov    0x10(%rsp),%rax
mov    %r15,(%rax)
mov    %rbx,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2d95(%rip),%rax
mov    (%rax),%edi
lea    0xdac(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [52 x i8] c"reallocating memory in createChunkListGSS function\0A\00"
define i64* @createChunkListGSS(i64 %0, i64 %1, i64 %2, i64* nocapture writeonly %3, i32 %4) {
%6 = icmp eq i32 %4, 0
%7 = xor i1 %6, true
%8 = zext i1 %7 to i64
%9 = lshr i64 %0, %8
%10 = icmp ne i64 %9, 0
br label %11
11: ; preds = %5, %24
%12 = phi i64* [ %18, %24 ], [ null, %5 ]
%13 = phi i64 [ %30, %24 ], [ %9, %5 ]
%14 = phi i64 [ %15, %24 ], [ 0, %5 ]
%15 = add i64 %14, 1
%16 = shl i64 %15, 3
%17 = tail call i64 @realloc(i64* %12, i64 %16)
%18 = inttoptr i64 %17 to i64*
%19 = icmp eq i64 %17, 0
br i1 %19, label %20, label %24
20: ; preds = %11
%21 = load i32, i32* @stderr
%22 = tail call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str, i64 0, i64 0))
%23 = tail call i32 @exit(i32 -1)
unreachable
24: ; preds = %11
%25 = udiv i64 %13, %1
%26 = icmp ult i64 %25, %2
%27 = icmp ult i64 %13, %2
%28 = select i1 %27, i64 %13, i64 %2
%29 = select i1 %26, i64 %28, i64 %25
%30 = sub i64 %13, %29
%31 = getelementptr inbounds i64, i64* %18, i64 %14
store i64 %29, i64* %31
%32 = icmp eq i64 %30, 0
br i1 %32, label %33, label %11
33: ; preds = %24
%34 = inttoptr i64 %17 to i64*
%35 = icmp ult i64 %29, %2
br i1 %35, label %36, label %39
36: ; preds = %33
%37 = load i64, i64* %34
%38 = add i64 %37, %29
store i64 %38, i64* %34
br label %39
39: ; preds = %36, %33
%40 = phi i64 [ %14, %36 ], [ %15, %33 ]
br i1 %6, label %55, label %41
41: ; preds = %39
%42 = shl i64 %40, 4
%43 = tail call i64 @malloc(i64 %42)
%44 = inttoptr i64 %43 to i64*
br label %45
45: ; preds = %45, %41
%46 = phi i64 [ %40, %41 ], [ %47, %45 ]
%47 = add i64 %46, -1
%48 = getelementptr inbounds i64, i64* %34, i64 %47
%49 = load i64, i64* %48
%50 = sub i64 %40, %46
%51 = getelementptr inbounds i64, i64* %44, i64 %50
store i64 %49, i64* %51
%52 = load i64, i64* %48
%53 = add i64 %47, %40
%54 = getelementptr inbounds i64, i64* %44, i64 %53
store i64 %52, i64* %54
br label %45
55: ; preds = %39
store i64 %40, i64* %3
ret i64* %34
}