int **jerasure_smart_bitmatrix_to_schedule(int k, int m, int w,
                                           int *bitmatrix) {
  int **operations;
  int op;
  int i, j;
  int *diff, *from, *b1, *flink, *blink;
  int *ptr, no, row;
  int optodo;
  int bestrow = 0, bestdiff, top;
  operations = (int **)malloc(sizeof(int *) * (k * m * w * w + 1));
  op = 0;
  diff = (int *)malloc(sizeof(int) * (m * w));
  from = (int *)malloc(sizeof(int) * (m * w));
  flink = (int *)malloc(sizeof(int) * (m * w));
  blink = (int *)malloc(sizeof(int) * (m * w));
  ptr = bitmatrix;
  bestdiff = k * w + 1;
  top = 0;
  for (i = 0; i < m * w; i++) {
    no = 0;
    for (j = 0; j < k * w; j++) {
      no += *ptr;
      ptr++;
    }
    diff[i] = no;
    from[i] = -1;
    flink[i] = i + 1;
    blink[i] = i - 1;
    if (no < bestdiff) {
      bestdiff = no;
      bestrow = i;
    }
  }
  flink[m * w - 1] = -1;
  while (top != -1) {
    row = bestrow;
    if (blink[row] == -1) {
      top = flink[row];
      if (top != -1)
        blink[top] = -1;
    } else {
      flink[blink[row]] = flink[row];
      if (flink[row] != -1) {
        blink[flink[row]] = blink[row];
      }
    }
    ptr = bitmatrix + row * k * w;
    if (from[row] == -1) {
      optodo = 0;
      for (j = 0; j < k * w; j++) {
        if (ptr[j]) {
          operations[op] = (int *)malloc(sizeof(int) * (5));
          operations[op][4] = optodo;
          operations[op][0] = j / w;
          operations[op][1] = j % w;
          operations[op][2] = k + row / w;
          operations[op][3] = row % w;
          optodo = 1;
          op++;
        }
      }
    } else {
      operations[op] = (int *)malloc(sizeof(int) * (5));
      operations[op][4] = 0;
      operations[op][0] = k + from[row] / w;
      operations[op][1] = from[row] % w;
      operations[op][2] = k + row / w;
      operations[op][3] = row % w;
      op++;
      b1 = bitmatrix + from[row] * k * w;
      for (j = 0; j < k * w; j++) {
        if (ptr[j] ^ b1[j]) {
          operations[op] = (int *)malloc(sizeof(int) * (5));
          operations[op][4] = 1;
          operations[op][0] = j / w;
          operations[op][1] = j % w;
          operations[op][2] = k + row / w;
          operations[op][3] = row % w;
          optodo = 1;
          op++;
        }
      }
    }
    bestdiff = k * w + 1;
    for (i = top; i != -1; i = flink[i]) {
      no = 1;
      b1 = bitmatrix + i * k * w;
      for (j = 0; j < k * w; j++)
        no += (ptr[j] ^ b1[j]);
      if (no < diff[i]) {
        from[i] = row;
        diff[i] = no;
      }
      if (diff[i] < bestdiff) {
        bestdiff = diff[i];
        bestrow = i;
      }
    }
  }
  operations[op] = (int *)malloc(sizeof(int) * (5));
  operations[op][0] = -1;
  free(from);
  free(diff);
  free(blink);
  free(flink);
  return operations;
}


x86 assembly (clang, -O0):
<jerasure_smart_bitmatrix_to_schedule>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x4(%rbp),%eax
imul   -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    12a9 <jerasure_smart_bitmatrix_to_schedule+0x189>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    123f <jerasure_smart_bitmatrix_to_schedule+0x11f>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1207 <jerasure_smart_bitmatrix_to_schedule+0xe7>
mov    -0x64(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
add    $0x1,%edx
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1296 <jerasure_smart_bitmatrix_to_schedule+0x176>
mov    -0x64(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    129b <jerasure_smart_bitmatrix_to_schedule+0x17b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e7 <jerasure_smart_bitmatrix_to_schedule+0xc7>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
cmpl   $0xffffffff,-0x78(%rbp)
je     1722 <jerasure_smart_bitmatrix_to_schedule+0x602>
mov    -0x70(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    130f <jerasure_smart_bitmatrix_to_schedule+0x1ef>
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
cmpl   $0xffffffff,-0x78(%rbp)
je     130a <jerasure_smart_bitmatrix_to_schedule+0x1ea>
mov    -0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    1362 <jerasure_smart_bitmatrix_to_schedule+0x242>
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x68(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     135d <jerasure_smart_bitmatrix_to_schedule+0x23d>
mov    -0x58(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x68(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1362 <jerasure_smart_bitmatrix_to_schedule+0x242>
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1474 <jerasure_smart_bitmatrix_to_schedule+0x354>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    146f <jerasure_smart_bitmatrix_to_schedule+0x34f>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     145c <jerasure_smart_bitmatrix_to_schedule+0x33c>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x6c(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x10(%rax)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %edx,0x4(%rax)
mov    -0x4(%rbp),%ecx
mov    -0x68(%rbp),%eax
cltd
idivl  -0xc(%rbp)
add    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x68(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %edx,0xc(%rax)
movl   $0x1,-0x6c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1461 <jerasure_smart_bitmatrix_to_schedule+0x341>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    139f <jerasure_smart_bitmatrix_to_schedule+0x27f>
jmp    1629 <jerasure_smart_bitmatrix_to_schedule+0x509>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x0,0x10(%rax)
mov    -0x4(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  -0xc(%rbp)
add    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x40(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %edx,0x4(%rax)
mov    -0x4(%rbp),%ecx
mov    -0x68(%rbp),%eax
cltd
idivl  -0xc(%rbp)
add    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x68(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %edx,0xc(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x68(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1624 <jerasure_smart_bitmatrix_to_schedule+0x504>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
xor    (%rcx,%rdx,4),%eax
cmp    $0x0,%eax
je     1611 <jerasure_smart_bitmatrix_to_schedule+0x4f1>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x1,0x10(%rax)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %edx,0x4(%rax)
mov    -0x4(%rbp),%ecx
mov    -0x68(%rbp),%eax
cltd
idivl  -0xc(%rbp)
add    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x68(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %edx,0xc(%rax)
movl   $0x1,-0x6c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1616 <jerasure_smart_bitmatrix_to_schedule+0x4f6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1546 <jerasure_smart_bitmatrix_to_schedule+0x426>
jmp    1629 <jerasure_smart_bitmatrix_to_schedule+0x509>
mov    -0x4(%rbp),%eax
imul   -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xffffffff,-0x28(%rbp)
je     171d <jerasure_smart_bitmatrix_to_schedule+0x5fd>
movl   $0x1,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    16ad <jerasure_smart_bitmatrix_to_schedule+0x58d>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
xor    (%rcx,%rdx,4),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1671 <jerasure_smart_bitmatrix_to_schedule+0x551>
mov    -0x64(%rbp),%eax
mov    -0x38(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    16dd <jerasure_smart_bitmatrix_to_schedule+0x5bd>
mov    -0x68(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x74(%rbp),%eax
jge    1705 <jerasure_smart_bitmatrix_to_schedule+0x5e5>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    170a <jerasure_smart_bitmatrix_to_schedule+0x5ea>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
jmp    163c <jerasure_smart_bitmatrix_to_schedule+0x51c>
jmp    12c1 <jerasure_smart_bitmatrix_to_schedule+0x1a1>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0xffffffff,(%rax)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jerasure_smart_bitmatrix_to_schedule>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rcx,0x20(%rsp)
mov    %esi,%ebp
mov    %edx,%r13d
mov    %edi,0x2c(%rsp)
imul   %edi,%r13d
mov    %edx,0x4(%rsp)
imul   %edx,%ebp
mov    %r13d,%eax
imul   %ebp,%eax
cltq
lea    0x8(,%rax,8),%rdi
call   1040 <malloc@plt>
mov    %rax,0x38(%rsp)
movslq %ebp,%r14
lea    0x0(,%r14,4),%rbx
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    0x1(%r13),%eax
mov    %eax,0x28(%rsp)
mov    $0x0,%r15d
mov    %r14,0x48(%rsp)
test   %r14d,%r14d
jle    1370 <jerasure_smart_bitmatrix_to_schedule+0x250>
mov    %ebp,%r12d
lea    -0x1(%r13),%r9d
lea    0x1(%r9),%r8
mov    %r8,0x18(%rsp)
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x50(%rsp)
mov    %r10,%r11
shl    $0x5,%r11
xor    %ebp,%ebp
mov    0x28(%rsp),%edx
xor    %r15d,%r15d
mov    0x20(%rsp),%rbx
mov    0x30(%rsp),%rdi
jmp    125b <jerasure_smart_bitmatrix_to_schedule+0x13b>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
mov    %ecx,(%rax,%rbp,4)
mov    0x40(%rsp),%rax
movl   $0xffffffff,(%rax,%rbp,4)
lea    0x1(%rbp),%rax
mov    0x8(%rsp),%rsi
mov    %eax,(%rsi,%rbp,4)
lea    -0x1(%rbp),%esi
cmp    %edx,%ecx
cmovl  %ebp,%r15d
mov    %esi,(%rdi,%rbp,4)
cmovl  %ecx,%edx
mov    %rax,%rbp
cmp    %r12,%rax
je     1370 <jerasure_smart_bitmatrix_to_schedule+0x250>
xor    %ecx,%ecx
test   %r13d,%r13d
jle    1220 <jerasure_smart_bitmatrix_to_schedule+0x100>
cmp    $0x7,%r9d
jae    1270 <jerasure_smart_bitmatrix_to_schedule+0x150>
xor    %r14d,%r14d
jmp    1358 <jerasure_smart_bitmatrix_to_schedule+0x238>
cmpq   $0x18,0x58(%rsp)
jae    1284 <jerasure_smart_bitmatrix_to_schedule+0x164>
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
jmp    12f9 <jerasure_smart_bitmatrix_to_schedule+0x1d9>
pxor   %xmm0,%xmm0
mov    0x50(%rsp),%rax
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rbx,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbx,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbx,%rcx,4),%xmm1
movdqu 0x30(%rbx,%rcx,4),%xmm3
movdqu 0x40(%rbx,%rcx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rbx,%rcx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rbx,%rcx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rbx,%rcx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    12a0 <jerasure_smart_bitmatrix_to_schedule+0x180>
test   %r10,%r10
je     132c <jerasure_smart_bitmatrix_to_schedule+0x20c>
lea    (%rbx,%rcx,4),%rax
add    $0x10,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rax,%rcx,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rax,%rcx,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rcx
cmp    %rcx,%r11
jne    1310 <jerasure_smart_bitmatrix_to_schedule+0x1f0>
paddd  %xmm1,%xmm0
lea    (%rbx,%r8,4),%rbx
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
mov    %r8d,%r14d
cmp    %r8,0x18(%rsp)
je     1220 <jerasure_smart_bitmatrix_to_schedule+0x100>
mov    %r13d,%eax
sub    %r14d,%eax
xchg   %ax,%ax
add    (%rbx),%ecx
add    $0x4,%rbx
add    $0xffffffff,%eax
jne    1360 <jerasure_smart_bitmatrix_to_schedule+0x240>
jmp    1220 <jerasure_smart_bitmatrix_to_schedule+0x100>
mov    0x8(%rsp),%r10
mov    0x48(%rsp),%rax
movl   $0xffffffff,-0x4(%r10,%rax,4)
ff ff
mov    %r13d,%r14d
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x58(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rcx,%rdx
mov    %rcx,0x48(%rsp)
and    %rcx,%rax
mov    %rax,0x80(%rsp)
mov    0x20(%rsp),%rax
add    $0x30,%rax
mov    %rax,0x70(%rsp)
xor    %r12d,%r12d
mov    0x10(%rsp),%r9
xor    %esi,%esi
mov    %r15d,%r11d
jmp    1401 <jerasure_smart_bitmatrix_to_schedule+0x2e1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8d,%r11d
mov    0x68(%rsp),%rsi
cmp    $0xffffffff,%esi
je     17c1 <jerasure_smart_bitmatrix_to_schedule+0x6a1>
movslq %r11d,%rax
mov    0x30(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
mov    (%r10,%rax,4),%edx
cmp    $0xffffffffffffffff,%rcx
je     1560 <jerasure_smart_bitmatrix_to_schedule+0x440>
mov    %edx,(%r10,%rcx,4)
mov    (%r10,%rax,4),%edx
mov    %rsi,%rdi
cmp    $0xffffffff,%edx
je     1438 <jerasure_smart_bitmatrix_to_schedule+0x318>
movslq %edx,%rdx
mov    0x30(%rsp),%rdi
mov    %ecx,(%rdi,%rdx,4)
mov    %esi,%edi
mov    %rdi,0x68(%rsp)
mov    %r13d,%ecx
imul   %r11d,%ecx
movslq %ecx,%rdx
mov    0x20(%rsp),%rcx
lea    (%rcx,%rdx,4),%r15
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,4),%ebx
cmp    $0xffffffff,%ebx
mov    %r11d,0x18(%rsp)
mov    %rdx,0x78(%rsp)
je     1580 <jerasure_smart_bitmatrix_to_schedule+0x460>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    0x18(%rsp),%r11d
mov    %rax,%rcx
mov    %ebx,%eax
cltd
mov    0x4(%rsp),%ebp
idiv   %ebp
mov    %edx,%r9d
mov    %eax,%edi
mov    %r11d,%eax
cltd
idiv   %ebp
mov    0x2c(%rsp),%ebp
add    %ebp,%edi
add    %ebp,%eax
lea    0x1(%r12),%r8d
movslq %r12d,%rsi
mov    0x38(%rsp),%rbp
mov    %rcx,0x0(%rbp,%rsi,8)
movl   $0x0,0x10(%rcx)
mov    %edi,(%rcx)
mov    %r9d,0x4(%rcx)
mov    %eax,0x64(%rsp)
mov    %eax,0x8(%rcx)
mov    %edx,0x60(%rsp)
mov    %edx,0xc(%rcx)
test   %r13d,%r13d
jle    1600 <jerasure_smart_bitmatrix_to_schedule+0x4e0>
imul   %r13d,%ebx
movslq %ebx,%rcx
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,4),%rbp
xor    %ebx,%ebx
mov    %r8d,%r12d
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r10
jmp    14fd <jerasure_smart_bitmatrix_to_schedule+0x3dd>
add    $0x1,%rbx
cmp    %rbx,%r14
je     160d <jerasure_smart_bitmatrix_to_schedule+0x4ed>
mov    (%r15,%rbx,4),%eax
cmp    0x0(%rbp,%rbx,4),%eax
je     14f0 <jerasure_smart_bitmatrix_to_schedule+0x3d0>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    0x18(%rsp),%r11d
mov    0x8(%rsp),%r10
mov    0x10(%rsp),%r9
mov    %rax,%rcx
movslq %r12d,%r12
mov    0x38(%rsp),%rax
mov    %rcx,(%rax,%r12,8)
movl   $0x1,0x10(%rcx)
mov    %ebx,%eax
cltd
idivl  0x4(%rsp)
mov    %eax,(%rcx)
mov    %edx,0x4(%rcx)
mov    0x64(%rsp),%eax
mov    %eax,0x8(%rcx)
mov    0x60(%rsp),%eax
mov    %eax,0xc(%rcx)
add    $0x1,%r12d
jmp    14f0 <jerasure_smart_bitmatrix_to_schedule+0x3d0>
cs nopw 0x0(%rax,%rax,1)
mov    $0xffffffff,%ecx
mov    %edx,%esi
mov    $0xffffffff,%edi
cmp    $0xffffffff,%edx
jne    142b <jerasure_smart_bitmatrix_to_schedule+0x30b>
jmp    1438 <jerasure_smart_bitmatrix_to_schedule+0x318>
nopw   0x0(%rax,%rax,1)
test   %r13d,%r13d
jle    160d <jerasure_smart_bitmatrix_to_schedule+0x4ed>
xor    %ebx,%ebx
xor    %ebp,%ebp
jmp    1599 <jerasure_smart_bitmatrix_to_schedule+0x479>
nop
add    $0x1,%rbx
cmp    %rbx,%r14
je     160d <jerasure_smart_bitmatrix_to_schedule+0x4ed>
cmpl   $0x0,(%r15,%rbx,4)
je     1590 <jerasure_smart_bitmatrix_to_schedule+0x470>
mov    $0x14,%edi
call   1040 <malloc@plt>
mov    0x18(%rsp),%r11d
mov    0x8(%rsp),%r10
mov    0x10(%rsp),%r9
mov    %rax,%rcx
movslq %r12d,%r12
mov    0x38(%rsp),%rax
mov    %rcx,(%rax,%r12,8)
mov    %ebp,0x10(%rcx)
mov    %ebx,%eax
cltd
mov    0x4(%rsp),%esi
idiv   %esi
mov    %eax,(%rcx)
mov    %edx,0x4(%rcx)
mov    %r11d,%eax
cltd
idiv   %esi
add    0x2c(%rsp),%eax
mov    %eax,0x8(%rcx)
mov    %edx,0xc(%rcx)
add    $0x1,%r12d
mov    $0x1,%ebp
jmp    1590 <jerasure_smart_bitmatrix_to_schedule+0x470>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r8d,%r12d
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r10
mov    0x68(%rsp),%rax
cmp    $0xffffffff,%eax
je     17c1 <jerasure_smart_bitmatrix_to_schedule+0x6a1>
mov    0x70(%rsp),%rcx
mov    0x78(%rsp),%rdx
lea    (%rcx,%rdx,4),%rcx
mov    0x28(%rsp),%edx
mov    %r11d,%r8d
mov    %eax,%esi
jmp    1656 <jerasure_smart_bitmatrix_to_schedule+0x536>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %edx,%ebp
cmovl  %esi,%r8d
cmovl  %ebp,%edx
mov    (%r10,%rdi,4),%esi
cmp    $0xffffffff,%esi
je     13f0 <jerasure_smart_bitmatrix_to_schedule+0x2d0>
test   %r13d,%r13d
jle    1680 <jerasure_smart_bitmatrix_to_schedule+0x560>
mov    %r13d,%eax
imul   %esi,%eax
cltq
mov    0x20(%rsp),%rdi
lea    (%rdi,%rax,4),%rdi
cmp    $0x8,%r13d
jae    1690 <jerasure_smart_bitmatrix_to_schedule+0x570>
mov    $0x1,%eax
xor    %ebp,%ebp
jmp    1770 <jerasure_smart_bitmatrix_to_schedule+0x650>
xchg   %ax,%ax
mov    $0x1,%eax
jmp    1782 <jerasure_smart_bitmatrix_to_schedule+0x662>
nopw   0x0(%rax,%rax,1)
cmpq   $0x0,0x50(%rsp)
je     17a6 <jerasure_smart_bitmatrix_to_schedule+0x686>
mov    0x70(%rsp),%rbx
lea    (%rbx,%rax,4),%rbp
pxor   %xmm0,%xmm0
mov    0x80(%rsp),%rax
xor    %ebx,%ebx
movdqa 0x945(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rcx,%rbx,4),%xmm2
movdqu -0x20(%rcx,%rbx,4),%xmm3
movdqu -0x10(%rcx,%rbx,4),%xmm4
movdqu (%rcx,%rbx,4),%xmm5
movdqu -0x30(%rbp,%rbx,4),%xmm6
pxor   %xmm2,%xmm6
paddd  %xmm1,%xmm6
movdqu -0x20(%rbp,%rbx,4),%xmm2
pxor   %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbp,%rbx,4),%xmm1
pxor   %xmm4,%xmm1
paddd  %xmm6,%xmm1
movdqu 0x0(%rbp,%rbx,4),%xmm0
pxor   %xmm5,%xmm0
paddd  %xmm2,%xmm0
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    16c0 <jerasure_smart_bitmatrix_to_schedule+0x5a0>
testb  $0x1,0x48(%rsp)
je     1748 <jerasure_smart_bitmatrix_to_schedule+0x628>
movdqu (%r15,%rbx,4),%xmm2
movdqu 0x10(%r15,%rbx,4),%xmm3
movdqu (%rdi,%rbx,4),%xmm4
pxor   %xmm2,%xmm4
paddd  %xmm4,%xmm1
movdqu 0x10(%rdi,%rbx,4),%xmm2
pxor   %xmm3,%xmm2
paddd  %xmm2,%xmm0
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
mov    0x58(%rsp),%rbx
mov    %rbx,%rbp
cmp    %r14,%rbx
je     1782 <jerasure_smart_bitmatrix_to_schedule+0x662>
nop
mov    (%rdi,%rbp,4),%ebx
xor    (%r15,%rbp,4),%ebx
add    %ebx,%eax
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1770 <jerasure_smart_bitmatrix_to_schedule+0x650>
movslq %esi,%rdi
mov    (%r9,%rdi,4),%ebp
cmp    %ebp,%eax
jge    1640 <jerasure_smart_bitmatrix_to_schedule+0x520>
mov    0x40(%rsp),%rbp
mov    %r11d,0x0(%rbp,%rdi,4)
mov    %eax,(%r9,%rdi,4)
mov    %eax,%ebp
jmp    1640 <jerasure_smart_bitmatrix_to_schedule+0x520>
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
movdqa 0x84c(%rip),%xmm1
testb  $0x1,0x48(%rsp)
jne    1720 <jerasure_smart_bitmatrix_to_schedule+0x600>
jmp    1748 <jerasure_smart_bitmatrix_to_schedule+0x628>
mov    $0x14,%edi
mov    %r9,%rbp
mov    %r10,%r14
call   1040 <malloc@plt>
movslq %r12d,%rcx
mov    0x38(%rsp),%rbx
mov    %rax,(%rbx,%rcx,8)
movl   $0xffffffff,(%rax)
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32** @jerasure_smart_bitmatrix_to_schedule(i32 %0, i32 %1, i32 %2, i32* %3) {
%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 i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32* %3, i32** %8
store i32 0, i32* %22
%25 = load i32, i32* %5
%26 = load i32, i32* %6
%27 = mul nsw i32 %25, %26
%28 = load i32, i32* %7
%29 = mul nsw i32 %27, %28
%30 = load i32, i32* %7
%31 = mul nsw i32 %29, %30
%32 = add nsw i32 %31, 1
%33 = sext i32 %32 to i64
%34 = mul i64 8, %33
%35 = call i8* @malloc(i64 %34)
%36 = bitcast i8* %35 to i32**
store i32** %36, i32*** %9
store i32 0, i32* %10
%37 = load i32, i32* %6
%38 = load i32, i32* %7
%39 = mul nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = mul i64 4, %40
%42 = call i8* @malloc(i64 %41)
%43 = bitcast i8* %42 to i32*
store i32* %43, i32** %13
%44 = load i32, i32* %6
%45 = load i32, i32* %7
%46 = mul nsw i32 %44, %45
%47 = sext i32 %46 to i64
%48 = mul i64 4, %47
%49 = call i8* @malloc(i64 %48)
%50 = bitcast i8* %49 to i32*
store i32* %50, i32** %14
%51 = load i32, i32* %6
%52 = load i32, i32* %7
%53 = mul nsw i32 %51, %52
%54 = sext i32 %53 to i64
%55 = mul i64 4, %54
%56 = call i8* @malloc(i64 %55)
%57 = bitcast i8* %56 to i32*
store i32* %57, i32** %16
%58 = load i32, i32* %6
%59 = load i32, i32* %7
%60 = mul nsw i32 %58, %59
%61 = sext i32 %60 to i64
%62 = mul i64 4, %61
%63 = call i8* @malloc(i64 %62)
%64 = bitcast i8* %63 to i32*
store i32* %64, i32** %17
%65 = load i32*, i32** %8
store i32* %65, i32** %18
%66 = load i32, i32* %5
%67 = load i32, i32* %7
%68 = mul nsw i32 %66, %67
%69 = add nsw i32 %68, 1
store i32 %69, i32* %23
store i32 0, i32* %24
store i32 0, i32* %11
br label %70
70: ; preds = %122, %4
%71 = load i32, i32* %11
%72 = load i32, i32* %6
%73 = load i32, i32* %7
%74 = mul nsw i32 %72, %73
%75 = icmp slt i32 %71, %74
br i1 %75, label %76, label %125
76: ; preds = %70
store i32 0, i32* %19
store i32 0, i32* %12
br label %77
77: ; preds = %90, %76
%78 = load i32, i32* %12
%79 = load i32, i32* %5
%80 = load i32, i32* %7
%81 = mul nsw i32 %79, %80
%82 = icmp slt i32 %78, %81
br i1 %82, label %83, label %93
83: ; preds = %77
%84 = load i32*, i32** %18
%85 = load i32, i32* %84
%86 = load i32, i32* %19
%87 = add nsw i32 %86, %85
store i32 %87, i32* %19
%88 = load i32*, i32** %18
%89 = getelementptr inbounds i32, i32* %88, i32 1
store i32* %89, i32** %18
br label %90
90: ; preds = %83
%91 = load i32, i32* %12
%92 = add nsw i32 %91, 1
store i32 %92, i32* %12
br label %77
93: ; preds = %77
%94 = load i32, i32* %19
%95 = load i32*, i32** %13
%96 = load i32, i32* %11
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %95, i64 %97
store i32 %94, i32* %98
%99 = load i32*, i32** %14
%100 = load i32, i32* %11
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %99, i64 %101
store i32 -1, i32* %102
%103 = load i32, i32* %11
%104 = add nsw i32 %103, 1
%105 = load i32*, i32** %16
%106 = load i32, i32* %11
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i32, i32* %105, i64 %107
store i32 %104, i32* %108
%109 = load i32, i32* %11
%110 = sub nsw i32 %109, 1
%111 = load i32*, i32** %17
%112 = load i32, i32* %11
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %111, i64 %113
store i32 %110, i32* %114
%115 = load i32, i32* %19
%116 = load i32, i32* %23
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %121
118: ; preds = %93
%119 = load i32, i32* %19
store i32 %119, i32* %23
%120 = load i32, i32* %11
store i32 %120, i32* %22
br label %121
121: ; preds = %118, %93
br label %122
122: ; preds = %121
%123 = load i32, i32* %11
%124 = add nsw i32 %123, 1
store i32 %124, i32* %11
br label %70
125: ; preds = %70
%126 = load i32*, i32** %16
%127 = load i32, i32* %6
%128 = load i32, i32* %7
%129 = mul nsw i32 %127, %128
%130 = sub nsw i32 %129, 1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %126, i64 %131
store i32 -1, i32* %132
br label %133
133: ; preds = %515, %125
%134 = load i32, i32* %24
%135 = icmp ne i32 %134, -1
br i1 %135, label %136, label %516
136: ; preds = %133
%137 = load i32, i32* %22
store i32 %137, i32* %20
%138 = load i32*, i32** %17
%139 = load i32, i32* %20
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %138, i64 %140
%142 = load i32, i32* %141
%143 = icmp eq i32 %142, -1
br i1 %143, label %144, label %158
144: ; preds = %136
%145 = load i32*, i32** %16
%146 = load i32, i32* %20
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
%149 = load i32, i32* %148
store i32 %149, i32* %24
%150 = load i32, i32* %24
%151 = icmp ne i32 %150, -1
br i1 %151, label %152, label %157
152: ; preds = %144
%153 = load i32*, i32** %17
%154 = load i32, i32* %24
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
store i32 -1, i32* %156
br label %157
157: ; preds = %152, %144
br label %193
158: ; preds = %136
%159 = load i32*, i32** %16
%160 = load i32, i32* %20
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %159, i64 %161
%163 = load i32, i32* %162
%164 = load i32*, i32** %16
%165 = load i32*, i32** %17
%166 = load i32, i32* %20
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %165, i64 %167
%169 = load i32, i32* %168
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %164, i64 %170
store i32 %163, i32* %171
%172 = load i32*, i32** %16
%173 = load i32, i32* %20
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %172, i64 %174
%176 = load i32, i32* %175
%177 = icmp ne i32 %176, -1
br i1 %177, label %178, label %192
178: ; preds = %158
%179 = load i32*, i32** %17
%180 = load i32, i32* %20
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
%183 = load i32, i32* %182
%184 = load i32*, i32** %17
%185 = load i32*, i32** %16
%186 = load i32, i32* %20
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32, i32* %185, i64 %187
%189 = load i32, i32* %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %184, i64 %190
store i32 %183, i32* %191
br label %192
192: ; preds = %178, %158
br label %193
193: ; preds = %192, %157
%194 = load i32*, i32** %8
%195 = load i32, i32* %20
%196 = load i32, i32* %5
%197 = mul nsw i32 %195, %196
%198 = load i32, i32* %7
%199 = mul nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i32, i32* %194, i64 %200
store i32* %201, i32** %18
%202 = load i32*, i32** %14
%203 = load i32, i32* %20
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %202, i64 %204
%206 = load i32, i32* %205
%207 = icmp eq i32 %206, -1
br i1 %207, label %208, label %281
208: ; preds = %193
store i32 0, i32* %21
store i32 0, i32* %12
br label %209
209: ; preds = %277, %208
%210 = load i32, i32* %12
%211 = load i32, i32* %5
%212 = load i32, i32* %7
%213 = mul nsw i32 %211, %212
%214 = icmp slt i32 %210, %213
br i1 %214, label %215, label %280
215: ; preds = %209
%216 = load i32*, i32** %18
%217 = load i32, i32* %12
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i32, i32* %216, i64 %218
%220 = load i32, i32* %219
%221 = icmp ne i32 %220, 0
br i1 %221, label %222, label %276
222: ; preds = %215
%223 = call i8* @malloc(i64 20)
%224 = bitcast i8* %223 to i32*
%225 = load i32**, i32*** %9
%226 = load i32, i32* %10
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i32*, i32** %225, i64 %227
store i32* %224, i32** %228
%229 = load i32, i32* %21
%230 = load i32**, i32*** %9
%231 = load i32, i32* %10
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32*, i32** %230, i64 %232
%234 = load i32*, i32** %233
%235 = getelementptr inbounds i32, i32* %234, i64 4
store i32 %229, i32* %235
%236 = load i32, i32* %12
%237 = load i32, i32* %7
%238 = sdiv i32 %236, %237
%239 = load i32**, i32*** %9
%240 = load i32, i32* %10
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32*, i32** %239, i64 %241
%243 = load i32*, i32** %242
%244 = getelementptr inbounds i32, i32* %243, i64 0
store i32 %238, i32* %244
%245 = load i32, i32* %12
%246 = load i32, i32* %7
%247 = srem i32 %245, %246
%248 = load i32**, i32*** %9
%249 = load i32, i32* %10
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32*, i32** %248, i64 %250
%252 = load i32*, i32** %251
%253 = getelementptr inbounds i32, i32* %252, i64 1
store i32 %247, i32* %253
%254 = load i32, i32* %5
%255 = load i32, i32* %20
%256 = load i32, i32* %7
%257 = sdiv i32 %255, %256
%258 = add nsw i32 %254, %257
%259 = load i32**, i32*** %9
%260 = load i32, i32* %10
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i32*, i32** %259, i64 %261
%263 = load i32*, i32** %262
%264 = getelementptr inbounds i32, i32* %263, i64 2
store i32 %258, i32* %264
%265 = load i32, i32* %20
%266 = load i32, i32* %7
%267 = srem i32 %265, %266
%268 = load i32**, i32*** %9
%269 = load i32, i32* %10
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32*, i32** %268, i64 %270
%272 = load i32*, i32** %271
%273 = getelementptr inbounds i32, i32* %272, i64 3
store i32 %267, i32* %273
store i32 1, i32* %21
%274 = load i32, i32* %10
%275 = add nsw i32 %274, 1
store i32 %275, i32* %10
br label %276
276: ; preds = %222, %215
br label %277
277: ; preds = %276
%278 = load i32, i32* %12
%279 = add nsw i32 %278, 1
store i32 %279, i32* %12
br label %209
280: ; preds = %209
br label %433
281: ; preds = %193
%282 = call i8* @malloc(i64 20)
%283 = bitcast i8* %282 to i32*
%284 = load i32**, i32*** %9
%285 = load i32, i32* %10
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i32*, i32** %284, i64 %286
store i32* %283, i32** %287
%288 = load i32**, i32*** %9
%289 = load i32, i32* %10
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i32*, i32** %288, i64 %290
%292 = load i32*, i32** %291
%293 = getelementptr inbounds i32, i32* %292, i64 4
store i32 0, i32* %293
%294 = load i32, i32* %5
%295 = load i32*, i32** %14
%296 = load i32, i32* %20
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %295, i64 %297
%299 = load i32, i32* %298
%300 = load i32, i32* %7
%301 = sdiv i32 %299, %300
%302 = add nsw i32 %294, %301
%303 = load i32**, i32*** %9
%304 = load i32, i32* %10
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i32*, i32** %303, i64 %305
%307 = load i32*, i32** %306
%308 = getelementptr inbounds i32, i32* %307, i64 0
store i32 %302, i32* %308
%309 = load i32*, i32** %14
%310 = load i32, i32* %20
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i32, i32* %309, i64 %311
%313 = load i32, i32* %312
%314 = load i32, i32* %7
%315 = srem i32 %313, %314
%316 = load i32**, i32*** %9
%317 = load i32, i32* %10
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds i32*, i32** %316, i64 %318
%320 = load i32*, i32** %319
%321 = getelementptr inbounds i32, i32* %320, i64 1
store i32 %315, i32* %321
%322 = load i32, i32* %5
%323 = load i32, i32* %20
%324 = load i32, i32* %7
%325 = sdiv i32 %323, %324
%326 = add nsw i32 %322, %325
%327 = load i32**, i32*** %9
%328 = load i32, i32* %10
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i32*, i32** %327, i64 %329
%331 = load i32*, i32** %330
%332 = getelementptr inbounds i32, i32* %331, i64 2
store i32 %326, i32* %332
%333 = load i32, i32* %20
%334 = load i32, i32* %7
%335 = srem i32 %333, %334
%336 = load i32**, i32*** %9
%337 = load i32, i32* %10
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32*, i32** %336, i64 %338
%340 = load i32*, i32** %339
%341 = getelementptr inbounds i32, i32* %340, i64 3
store i32 %335, i32* %341
%342 = load i32, i32* %10
%343 = add nsw i32 %342, 1
store i32 %343, i32* %10
%344 = load i32*, i32** %8
%345 = load i32*, i32** %14
%346 = load i32, i32* %20
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i32, i32* %345, i64 %347
%349 = load i32, i32* %348
%350 = load i32, i32* %5
%351 = mul nsw i32 %349, %350
%352 = load i32, i32* %7
%353 = mul nsw i32 %351, %352
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i32, i32* %344, i64 %354
store i32* %355, i32** %15
store i32 0, i32* %12
br label %356
356: ; preds = %429, %281
%357 = load i32, i32* %12
%358 = load i32, i32* %5
%359 = load i32, i32* %7
%360 = mul nsw i32 %358, %359
%361 = icmp slt i32 %357, %360
br i1 %361, label %362, label %432
362: ; preds = %356
%363 = load i32*, i32** %18
%364 = load i32, i32* %12
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %363, i64 %365
%367 = load i32, i32* %366
%368 = load i32*, i32** %15
%369 = load i32, i32* %12
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i32, i32* %368, i64 %370
%372 = load i32, i32* %371
%373 = xor i32 %367, %372
%374 = icmp ne i32 %373, 0
br i1 %374, label %375, label %428
375: ; preds = %362
%376 = call i8* @malloc(i64 20)
%377 = bitcast i8* %376 to i32*
%378 = load i32**, i32*** %9
%379 = load i32, i32* %10
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds i32*, i32** %378, i64 %380
store i32* %377, i32** %381
%382 = load i32**, i32*** %9
%383 = load i32, i32* %10
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i32*, i32** %382, i64 %384
%386 = load i32*, i32** %385
%387 = getelementptr inbounds i32, i32* %386, i64 4
store i32 1, i32* %387
%388 = load i32, i32* %12
%389 = load i32, i32* %7
%390 = sdiv i32 %388, %389
%391 = load i32**, i32*** %9
%392 = load i32, i32* %10
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds i32*, i32** %391, i64 %393
%395 = load i32*, i32** %394
%396 = getelementptr inbounds i32, i32* %395, i64 0
store i32 %390, i32* %396
%397 = load i32, i32* %12
%398 = load i32, i32* %7
%399 = srem i32 %397, %398
%400 = load i32**, i32*** %9
%401 = load i32, i32* %10
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds i32*, i32** %400, i64 %402
%404 = load i32*, i32** %403
%405 = getelementptr inbounds i32, i32* %404, i64 1
store i32 %399, i32* %405
%406 = load i32, i32* %5
%407 = load i32, i32* %20
%408 = load i32, i32* %7
%409 = sdiv i32 %407, %408
%410 = add nsw i32 %406, %409
%411 = load i32**, i32*** %9
%412 = load i32, i32* %10
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i32*, i32** %411, i64 %413
%415 = load i32*, i32** %414
%416 = getelementptr inbounds i32, i32* %415, i64 2
store i32 %410, i32* %416
%417 = load i32, i32* %20
%418 = load i32, i32* %7
%419 = srem i32 %417, %418
%420 = load i32**, i32*** %9
%421 = load i32, i32* %10
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds i32*, i32** %420, i64 %422
%424 = load i32*, i32** %423
%425 = getelementptr inbounds i32, i32* %424, i64 3
store i32 %419, i32* %425
store i32 1, i32* %21
%426 = load i32, i32* %10
%427 = add nsw i32 %426, 1
store i32 %427, i32* %10
br label %428
428: ; preds = %375, %362
br label %429
429: ; preds = %428
%430 = load i32, i32* %12
%431 = add nsw i32 %430, 1
store i32 %431, i32* %12
br label %356
432: ; preds = %356
br label %433
433: ; preds = %432, %280
%434 = load i32, i32* %5
%435 = load i32, i32* %7
%436 = mul nsw i32 %434, %435
%437 = add nsw i32 %436, 1
store i32 %437, i32* %23
%438 = load i32, i32* %24
store i32 %438, i32* %11
br label %439
439: ; preds = %509, %433
%440 = load i32, i32* %11
%441 = icmp ne i32 %440, -1
br i1 %441, label %442, label %515
442: ; preds = %439
store i32 1, i32* %19
%443 = load i32*, i32** %8
%444 = load i32, i32* %11
%445 = load i32, i32* %5
%446 = mul nsw i32 %444, %445
%447 = load i32, i32* %7
%448 = mul nsw i32 %446, %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i32, i32* %443, i64 %449
store i32* %450, i32** %15
store i32 0, i32* %12
br label %451
451: ; preds = %471, %442
%452 = load i32, i32* %12
%453 = load i32, i32* %5
%454 = load i32, i32* %7
%455 = mul nsw i32 %453, %454
%456 = icmp slt i32 %452, %455
br i1 %456, label %457, label %474
457: ; preds = %451
%458 = load i32*, i32** %18
%459 = load i32, i32* %12
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i32, i32* %458, i64 %460
%462 = load i32, i32* %461
%463 = load i32*, i32** %15
%464 = load i32, i32* %12
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds i32, i32* %463, i64 %465
%467 = load i32, i32* %466
%468 = xor i32 %462, %467
%469 = load i32, i32* %19
%470 = add nsw i32 %469, %468
store i32 %470, i32* %19
br label %471
471: ; preds = %457
%472 = load i32, i32* %12
%473 = add nsw i32 %472, 1
store i32 %473, i32* %12
br label %451
474: ; preds = %451
%475 = load i32, i32* %19
%476 = load i32*, i32** %13
%477 = load i32, i32* %11
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds i32, i32* %476, i64 %478
%480 = load i32, i32* %479
%481 = icmp slt i32 %475, %480
br i1 %481, label %482, label %493
482: ; preds = %474
%483 = load i32, i32* %20
%484 = load i32*, i32** %14
%485 = load i32, i32* %11
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds i32, i32* %484, i64 %486
store i32 %483, i32* %487
%488 = load i32, i32* %19
%489 = load i32*, i32** %13
%490 = load i32, i32* %11
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i32, i32* %489, i64 %491
store i32 %488, i32* %492
br label %493
493: ; preds = %482, %474
%494 = load i32*, i32** %13
%495 = load i32, i32* %11
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds i32, i32* %494, i64 %496
%498 = load i32, i32* %497
%499 = load i32, i32* %23
%500 = icmp slt i32 %498, %499
br i1 %500, label %501, label %508
501: ; preds = %493
%502 = load i32*, i32** %13
%503 = load i32, i32* %11
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds i32, i32* %502, i64 %504
%506 = load i32, i32* %505
store i32 %506, i32* %23
%507 = load i32, i32* %11
store i32 %507, i32* %22
br label %508
508: ; preds = %501, %493
br label %509
509: ; preds = %508
%510 = load i32*, i32** %16
%511 = load i32, i32* %11
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds i32, i32* %510, i64 %512
%514 = load i32, i32* %513
store i32 %514, i32* %11
br label %439
515: ; preds = %439
br label %133
516: ; preds = %133
%517 = call i8* @malloc(i64 20)
%518 = bitcast i8* %517 to i32*
%519 = load i32**, i32*** %9
%520 = load i32, i32* %10
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds i32*, i32** %519, i64 %521
store i32* %518, i32** %522
%523 = load i32**, i32*** %9
%524 = load i32, i32* %10
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds i32*, i32** %523, i64 %525
%527 = load i32*, i32** %526
%528 = getelementptr inbounds i32, i32* %527, i64 0
store i32 -1, i32* %528
%529 = load i32*, i32** %14
%530 = bitcast i32* %529 to i8*
%531 = load i32*, i32** %13
%532 = bitcast i32* %531 to i8*
%533 = load i32*, i32** %17
%534 = bitcast i32* %533 to i8*
%535 = load i32*, i32** %16
%536 = bitcast i32* %535 to i8*
%537 = load i32**, i32*** %9
ret i32** %537
}

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