void form_member_list(const double *Z, int *members, int n) {
  int *curNode, *left;
  int ndid, lid, rid, k, ln, rn;
  unsigned char *lvisited, *rvisited;
  const double *Zrow;
  const int bff = (((((double)(n)) / (double)(sizeof(unsigned char) * 8)) ==
                            ((double)(((n)) / ((sizeof(unsigned char) * 8))))
                        ? (((n)) / ((sizeof(unsigned char) * 8)))
                        : (((n)) / ((sizeof(unsigned char) * 8)) + 1)));
  k = 0;
  curNode = (int *)malloc(n * sizeof(int));
  left = (int *)malloc(n * sizeof(int));
  lvisited = (unsigned char *)malloc(bff);
  rvisited = (unsigned char *)malloc(bff);
  curNode[k] = (n * 2) - 2;
  left[k] = 0;
  bzero(lvisited, bff);
  bzero(rvisited, bff);
  while (k >= 0) {
    ndid = curNode[k];
    Zrow = Z + ((ndid - n) * 4);
    lid = (int)Zrow[0];
    rid = (int)Zrow[1];
    if (lid >= n) {
      ln = (int)*(Z + (4 * (lid - n)) + 3);
    } else {
      ln = 1;
    }
    if (rid >= n) {
      rn = (int)*(Z + (4 * (rid - n)) + 3);
    } else {
      rn = 1;
    }
    if (lid >= n && !(((lvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] >>
                       (((sizeof(unsigned char) * 8) - 1) -
                        ((ndid - n) % (sizeof(unsigned char) * 8)))) &
                      0x1)) {
      ((lvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] |=
       ((0x1) << (((sizeof(unsigned char) * 8) - 1) -
                  ((ndid - n) % (sizeof(unsigned char) * 8)))));
      curNode[k + 1] = lid;
      left[k + 1] = left[k];
      k++;
      continue;
    } else if (lid < n) {
      members[left[k]] = lid;
    }
    if (rid >= n && !(((rvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] >>
                       (((sizeof(unsigned char) * 8) - 1) -
                        ((ndid - n) % (sizeof(unsigned char) * 8)))) &
                      0x1)) {
      ((rvisited)[(ndid - n) / (sizeof(unsigned char) * 8)] |=
       ((0x1) << (((sizeof(unsigned char) * 8) - 1) -
                  ((ndid - n) % (sizeof(unsigned char) * 8)))));
      curNode[k + 1] = rid;
      left[k + 1] = left[k] + ln;
      k++;
      continue;
    } else if (rid < n) {
      members[left[k] + ln] = rid;
    }
    k--;
  }
  free(curNode);
  free(left);
  free(lvisited);
  free(rvisited);
}


x86 assembly (clang, -O0):
<form_member_list>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
mov    %eax,%ecx
cvtsi2sd %ecx,%xmm0
movsd  0xeab(%rip),%xmm1
divsd  %xmm1,%xmm0
shr    $0x3,%rax
cvtsi2sd %rax,%xmm1
ucomisd %xmm1,%xmm0
jne    1183 <form_member_list+0x53>
jp     1183 <form_member_list+0x53>
movslq -0x14(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x68(%rbp)
jmp    1193 <form_member_list+0x63>
movslq -0x14(%rbp),%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x38(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x5c(%rbp),%rdi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x5c(%rbp),%rdi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
sub    $0x2,%edx
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rdi
movslq -0x5c(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x50(%rbp),%rdi
movslq -0x5c(%rbp),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
cmpl   $0x0,-0x38(%rbp)
jl     149e <form_member_list+0x36e>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
cvttsd2si 0x8(%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1292 <form_member_list+0x162>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
cvttsd2si 0x18(%rax,%rcx,8),%eax
mov    %eax,-0x3c(%rbp)
jmp    1299 <form_member_list+0x169>
movl   $0x1,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     12c3 <form_member_list+0x193>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
cvttsd2si 0x18(%rax,%rcx,8),%eax
mov    %eax,-0x40(%rbp)
jmp    12ca <form_member_list+0x19a>
movl   $0x1,-0x40(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1382 <form_member_list+0x252>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rdx
and    $0x7,%rdx
mov    $0x7,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1382 <form_member_list+0x252>
mov    -0x2c(%rbp),%eax
sub    -0x14(%rbp),%eax
movslq %eax,%rcx
and    $0x7,%rcx
mov    $0x7,%eax
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    121e <form_member_list+0xee>
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13a4 <form_member_list+0x274>
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x38(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13a9 <form_member_list+0x279>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1464 <form_member_list+0x334>
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rdx
and    $0x7,%rdx
mov    $0x7,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1464 <form_member_list+0x334>
mov    -0x2c(%rbp),%eax
sub    -0x14(%rbp),%eax
movslq %eax,%rcx
and    $0x7,%rcx
mov    $0x7,%eax
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x1,%esi
shl    %cl,%esi
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
shr    $0x3,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    121e <form_member_list+0xee>
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    148b <form_member_list+0x35b>
mov    -0x34(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x38(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1490 <form_member_list+0x360>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    121e <form_member_list+0xee>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<form_member_list>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r14d
mov    %rsi,0x8(%rsp)
mov    %rdi,%r15
cvtsi2sd %edx,%xmm0
mulsd  0xeab(%rip),%xmm0
movslq %edx,%rax
mov    %rax,%rbx
mov    %rax,%rcx
mov    %rax,0x10(%rsp)
shr    $0x3,%rbx
cvtsi2sd %rbx,%xmm1
cmpneqsd %xmm0,%xmm1
movq   %xmm1,%rax
sub    %eax,%ebx
lea    0x0(,%rcx,4),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
movslq %ebx,%rbx
mov    $0x1,%edi
mov    %rbx,%rsi
call   1040 <calloc@plt>
mov    %rax,(%rsp)
mov    $0x1,%edi
mov    %rbx,%rsi
call   1040 <calloc@plt>
mov    0x10(%rsp),%rcx
add    %ecx,%ecx
add    $0xfffffffe,%ecx
mov    %ecx,(%r12)
movl   $0x0,0x0(%r13)
xor    %esi,%esi
mov    (%rsp),%r9
jmp    11f9 <form_member_list+0xc9>
or     %dl,%bpl
mov    %bpl,(%r9,%rsi,1)
lea    0x1(%r10),%esi
lea    0x1(%r10),%rcx
mov    %ebx,0x4(%r12,%r10,4)
mov    0x0(%r13,%r10,4),%edi
mov    %edi,0x0(%r13,%rcx,4)
mov    %esi,%ecx
mov    (%r12,%rcx,4),%ecx
mov    %esi,%r10d
sub    %r14d,%ecx
lea    0x0(,%rcx,4),%edx
movslq %edx,%rdx
cvttsd2si (%r15,%rdx,8),%ebx
cvttsd2si 0x8(%r15,%rdx,8),%r8d
mov    %ebx,%edi
sub    %r14d,%edi
jge    1240 <form_member_list+0x110>
movslq 0x0(%r13,%r10,4),%rsi
mov    0x8(%rsp),%rdx
mov    %ebx,(%rdx,%rsi,4)
cmp    %r14d,%r8d
jge    1290 <form_member_list+0x160>
mov    $0x1,%edi
jmp    127b <form_member_list+0x14b>
cs nopw 0x0(%rax,%rax,1)
movslq %ecx,%rsi
not    %cl
and    $0x7,%cl
mov    $0x1,%ebp
shl    %cl,%ebp
shr    $0x3,%rsi
movzbl (%r9,%rsi,1),%edx
movzbl %cl,%ecx
bt     %ecx,%edx
jae    11d5 <form_member_list+0xa5>
shl    $0x2,%edi
movslq %edi,%rcx
cvttsd2si 0x18(%r15,%rcx,8),%edi
cmp    %r14d,%r8d
jge    12a8 <form_member_list+0x178>
mov    0x0(%r13,%r10,4),%esi
add    %edi,%esi
movslq %esi,%rcx
mov    0x8(%rsp),%rdx
mov    %r8d,(%rdx,%rcx,4)
jmp    12b0 <form_member_list+0x180>
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rsi
shr    $0x3,%rsi
not    %cl
and    $0x7,%cl
mov    $0x1,%edi
mov    $0x1,%ebp
shl    %cl,%ebp
movzbl (%rax,%rsi,1),%ecx
test   %ecx,%ebp
je     12c1 <form_member_list+0x191>
test   %r10d,%r10d
jle    12df <form_member_list+0x1af>
add    $0xffffffff,%r10d
mov    %r10d,%esi
jmp    11f3 <form_member_list+0xc3>
or     %cl,%bpl
mov    %bpl,(%rax,%rsi,1)
lea    0x1(%r10),%esi
lea    0x1(%r10),%rcx
mov    %r8d,0x4(%r12,%r10,4)
add    0x0(%r13,%r10,4),%edi
jmp    11ee <form_member_list+0xbe>
mov    %r12,%rdi
mov    %rax,%rbx
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
define void @form_member_list(double* nocapture %0, i32* nocapture writeonly %1, i32 %2) {
%4 = sitofp i32 %2 to double
%5 = fmul double %4, 1.250000e-01
%6 = sext i32 %2 to i64
%7 = lshr i64 %6, 3
%8 = uitofp i64 %7 to double
%9 = fcmp une double %5, %8
%10 = zext i1 %9 to i64
%11 = add nuw nsw i64 %7, %10
%12 = shl nsw i64 %6, 2
%13 = tail call i8* @malloc(i64 %12)
%14 = bitcast i8* %13 to i32*
%15 = tail call i8* @malloc(i64 %12)
%16 = bitcast i8* %15 to i32*
%17 = shl i64 %11, 32
%18 = ashr exact i64 %17, 32
%19 = call i8* @calloc(i64 1, i64 %18)
%20 = call i8* @calloc(i64 1, i64 %18)
%21 = shl nsw i32 %2, 1
%22 = add nsw i32 %21, -2
store i32 %22, i32* %14
store i32 0, i32* %16
%23 = getelementptr inbounds double, double* %0, i64 3
br label %24
24: ; preds = %71, %3
%25 = phi i32 [ %22, %3 ], [ %75, %71 ]
%26 = phi i32 [ 0, %3 ], [ %72, %71 ]
%27 = zext i32 %26 to i64
%28 = sub nsw i32 %25, %2
%29 = shl nsw i32 %28, 2
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %0, i64 %30
%32 = load double, double* %31
%33 = fptosi double %32 to i32
%34 = getelementptr inbounds double, double* %31, i64 1
%35 = load double, double* %34
%36 = fptosi double %35 to i32
%37 = icmp slt i32 %33, %2
br i1 %37, label %76, label %38
38: ; preds = %24
%39 = sub nsw i32 %33, %2
%40 = shl nsw i32 %39, 2
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %23, i64 %41
%43 = load double, double* %42
%44 = fptosi double %43 to i32
%45 = sext i32 %28 to i64
%46 = lshr i64 %45, 3
%47 = getelementptr inbounds i8, i8* %19, i64 %46
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = and i32 %28, 7
%51 = xor i32 %50, 7
%52 = shl nuw i32 1, %51
%53 = and i32 %52, %49
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %88
55: ; preds = %38
%56 = trunc i32 %52 to i8
%57 = or i8 %48, %56
store i8 %57, i8* %47
%58 = add nuw nsw i32 %26, 1
%59 = zext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %14, i64 %59
store i32 %33, i32* %60
%61 = getelementptr inbounds i32, i32* %16, i64 %27
%62 = load i32, i32* %61
br label %66
63: ; preds = %111, %93
%64 = add nsw i32 %26, -1
%65 = icmp sgt i32 %26, 0
br i1 %65, label %71, label %117
66: ; preds = %102, %55
%67 = phi i64 [ %59, %55 ], [ %106, %102 ]
%68 = phi i32 [ %62, %55 ], [ %110, %102 ]
%69 = phi i32 [ %58, %55 ], [ %105, %102 ]
%70 = getelementptr inbounds i32, i32* %16, i64 %67
store i32 %68, i32* %70
br label %71
71: ; preds = %66, %63
%72 = phi i32 [ %64, %63 ], [ %69, %66 ]
%73 = zext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %14, i64 %73
%75 = load i32, i32* %74
br label %24
76: ; preds = %24
%77 = icmp slt i32 %36, %2
%78 = getelementptr inbounds i32, i32* %16, i64 %27
%79 = load i32, i32* %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %1, i64 %80
store i32 %33, i32* %81
br i1 %77, label %111, label %82
82: ; preds = %76
%83 = sext i32 %28 to i64
%84 = lshr i64 %83, 3
%85 = and i32 %28, 7
%86 = xor i32 %85, 7
%87 = shl nuw i32 1, %86
br label %93
88: ; preds = %38
%89 = icmp slt i32 %36, %2
br i1 %89, label %90, label %93
90: ; preds = %88
%91 = getelementptr inbounds i32, i32* %16, i64 %27
%92 = load i32, i32* %91
br label %111
93: ; preds = %82, %88
%94 = phi i32 [ %87, %82 ], [ %52, %88 ]
%95 = phi i64 [ %84, %82 ], [ %46, %88 ]
%96 = phi i32 [ 1, %82 ], [ %44, %88 ]
%97 = getelementptr inbounds i8, i8* %20, i64 %95
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = and i32 %94, %99
%101 = icmp eq i32 %100, 0
br i1 %101, label %102, label %63
102: ; preds = %93
%103 = trunc i32 %94 to i8
%104 = or i8 %98, %103
store i8 %104, i8* %97
%105 = add nuw nsw i32 %26, 1
%106 = zext i32 %105 to i64
%107 = getelementptr inbounds i32, i32* %14, i64 %106
store i32 %36, i32* %107
%108 = getelementptr inbounds i32, i32* %16, i64 %27
%109 = load i32, i32* %108
%110 = add nsw i32 %109, %96
br label %66
111: ; preds = %90, %76
%112 = phi i32 [ %92, %90 ], [ %79, %76 ]
%113 = phi i32 [ %44, %90 ], [ 1, %76 ]
%114 = add nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %1, i64 %115
store i32 %36, i32* %116
br label %63
117: ; preds = %63
tail call void @free(i8* %13)
tail call void @free(i8* %15)
tail call void @free(i8* %19)
tail call void @free(i8* %20)
ret void
}