#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*/ bzero(int *, int);
int /*<<< orphan*/ free(int *);
int **jerasure_dumb_bitmatrix_to_schedule(int, int, int, int *);
int /*<<< orphan*/ jerasure_invert_bitmatrix(int *, int *, int);
int **jerasure_smart_bitmatrix_to_schedule(int, int, int, int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(int *, int *, int);
scalar_t__ set_up_ids_for_scheduled_decoding(int, int, int *, int *, int *);
int **jerasure_generate_decoding_schedule(int k, int m, int w, int *bitmatrix,
                                          int *erasures, int smart) {
  int i, j, x, drive, y, index, z;
  int *decoding_matrix, *inverse, *real_decoding_matrix;
  int *ptr;
  int *row_ids;
  int *ind_to_row;
  int ddf, cdf;
  int **schedule;
  int *b1, *b2;
  ddf = 0;
  cdf = 0;
  for (i = 0; erasures[i] != -1; i++) {
    if (erasures[i] < k)
      ddf++;
    else
      cdf++;
  }
  row_ids = (int *)malloc(sizeof(int) * (k + m));
  ind_to_row = (int *)malloc(sizeof(int) * (k + m));
  if (set_up_ids_for_scheduled_decoding(k, m, erasures, row_ids, ind_to_row) <
      0)
    return NULL;
  real_decoding_matrix = (int *)malloc(sizeof(int) * (k * w * (cdf + ddf) * w));
  if (ddf > 0) {
    decoding_matrix = (int *)malloc(sizeof(int) * (k * k * w * w));
    ptr = decoding_matrix;
    for (i = 0; i < k; i++) {
      if (row_ids[i] == i) {
        bzero(ptr, k * w * w * sizeof(int));
        for (x = 0; x < w; x++) {
          ptr[x + i * w + x * k * w] = 1;
        }
      } else {
        memcpy(ptr, bitmatrix + k * w * w * (row_ids[i] - k),
               k * w * w * sizeof(int));
      }
      ptr += (k * w * w);
    }
    inverse = (int *)malloc(sizeof(int) * (k * k * w * w));
    jerasure_invert_bitmatrix(decoding_matrix, inverse, k * w);
    free(decoding_matrix);
    ptr = real_decoding_matrix;
    for (i = 0; i < ddf; i++) {
      memcpy(ptr, inverse + k * w * w * row_ids[k + i],
             sizeof(int) * k * w * w);
      ptr += (k * w * w);
    }
    free(inverse);
  }
  for (x = 0; x < cdf; x++) {
    drive = row_ids[x + ddf + k] - k;
    ptr = real_decoding_matrix + k * w * w * (ddf + x);
    memcpy(ptr, bitmatrix + drive * k * w * w, sizeof(int) * k * w * w);
    for (i = 0; i < k; i++) {
      if (row_ids[i] != i) {
        for (j = 0; j < w; j++) {
          bzero(ptr + j * k * w + i * w, sizeof(int) * w);
        }
      }
    }
    index = drive * k * w * w;
    for (i = 0; i < k; i++) {
      if (row_ids[i] != i) {
        b1 = real_decoding_matrix + (ind_to_row[i] - k) * k * w * w;
        for (j = 0; j < w; j++) {
          b2 = ptr + j * k * w;
          for (y = 0; y < w; y++) {
            if (bitmatrix[index + j * k * w + i * w + y]) {
              for (z = 0; z < k * w; z++) {
                b2[z] = b2[z] ^ b1[z + y * k * w];
              }
            }
          }
        }
      }
    }
  }
  if (smart) {
    schedule = jerasure_smart_bitmatrix_to_schedule(k, ddf + cdf, w,
                                                    real_decoding_matrix);
  } else {
    schedule = jerasure_dumb_bitmatrix_to_schedule(k, ddf + cdf, w,
                                                   real_decoding_matrix);
  }
  free(row_ids);
  free(ind_to_row);
  free(real_decoding_matrix);
  return schedule;
}


x86 assembly (clang, -O0):
<jerasure_generate_decoding_schedule>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     1205 <jerasure_generate_decoding_schedule+0x85>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xc(%rbp),%eax
jge    11e9 <jerasure_generate_decoding_schedule+0x69>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    11f2 <jerasure_generate_decoding_schedule+0x72>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    11f7 <jerasure_generate_decoding_schedule+0x77>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11b5 <jerasure_generate_decoding_schedule+0x35>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x78(%rbp),%r8
call   1040 <set_up_ids_for_scheduled_decoding@plt>
cmp    $0x0,%rax
jge    1261 <jerasure_generate_decoding_schedule+0xe1>
movq   $0x0,-0x8(%rbp)
jmp    17b6 <jerasure_generate_decoding_schedule+0x636>
mov    -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x80(%rbp),%ecx
add    -0x7c(%rbp),%ecx
imul   %ecx,%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jle    1490 <jerasure_generate_decoding_schedule+0x310>
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13b8 <jerasure_generate_decoding_schedule+0x238>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
jne    1348 <jerasure_generate_decoding_schedule+0x1c8>
mov    -0x68(%rbp),%rdi
mov    -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%esi
call   1090 <bzero@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1343 <jerasure_generate_decoding_schedule+0x1c3>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
mov    -0x38(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1302 <jerasure_generate_decoding_schedule+0x182>
jmp    138d <jerasure_generate_decoding_schedule+0x20d>
mov    -0x68(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x70(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0xc(%rbp),%ecx
imul   %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12bf <jerasure_generate_decoding_schedule+0x13f>
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0xc(%rbp),%edx
imul   -0x14(%rbp),%edx
call   1080 <jerasure_invert_bitmatrix@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1487 <jerasure_generate_decoding_schedule+0x307>
mov    -0x68(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x70(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x30(%rbp),%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1404 <jerasure_generate_decoding_schedule+0x284>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    1749 <jerasure_generate_decoding_schedule+0x5c9>
mov    -0x70(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x7c(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
add    -0x38(%rbp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x3c(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15b8 <jerasure_generate_decoding_schedule+0x438>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     15a5 <jerasure_generate_decoding_schedule+0x425>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a0 <jerasure_generate_decoding_schedule+0x420>
mov    -0x68(%rbp),%rdi
mov    -0x34(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%esi
call   1090 <bzero@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    154f <jerasure_generate_decoding_schedule+0x3cf>
jmp    15a5 <jerasure_generate_decoding_schedule+0x425>
jmp    15aa <jerasure_generate_decoding_schedule+0x42a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1528 <jerasure_generate_decoding_schedule+0x3a8>
mov    -0x3c(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1736 <jerasure_generate_decoding_schedule+0x5b6>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     1723 <jerasure_generate_decoding_schedule+0x5a3>
mov    -0x60(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0xc(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    171e <jerasure_generate_decoding_schedule+0x59e>
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    170b <jerasure_generate_decoding_schedule+0x58b>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     16f8 <jerasure_generate_decoding_schedule+0x578>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    16f3 <jerasure_generate_decoding_schedule+0x573>
mov    -0x98(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x90(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x40(%rbp),%esi
imul   -0xc(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    -0x98(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    169a <jerasure_generate_decoding_schedule+0x51a>
jmp    16f8 <jerasure_generate_decoding_schedule+0x578>
jmp    16fd <jerasure_generate_decoding_schedule+0x57d>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    165a <jerasure_generate_decoding_schedule+0x4da>
jmp    1710 <jerasure_generate_decoding_schedule+0x590>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1627 <jerasure_generate_decoding_schedule+0x4a7>
jmp    1723 <jerasure_generate_decoding_schedule+0x5a3>
jmp    1728 <jerasure_generate_decoding_schedule+0x5a8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15d1 <jerasure_generate_decoding_schedule+0x451>
jmp    173b <jerasure_generate_decoding_schedule+0x5bb>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1497 <jerasure_generate_decoding_schedule+0x317>
cmpl   $0x0,-0x2c(%rbp)
je     1774 <jerasure_generate_decoding_schedule+0x5f4>
mov    -0xc(%rbp),%edi
mov    -0x7c(%rbp),%esi
add    -0x80(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x60(%rbp),%rcx
call   1050 <jerasure_smart_bitmatrix_to_schedule@plt>
mov    %rax,-0x88(%rbp)
jmp    1790 <jerasure_generate_decoding_schedule+0x610>
mov    -0xc(%rbp),%edi
mov    -0x7c(%rbp),%esi
add    -0x80(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x60(%rbp),%rcx
call   10a0 <jerasure_dumb_bitmatrix_to_schedule@plt>
mov    %rax,-0x88(%rbp)
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jerasure_generate_decoding_schedule>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r8,%r14
mov    %rcx,0x58(%rsp)
mov    %rdx,(%rsp)
mov    %esi,%ebx
mov    %edi,%ebp
mov    (%r8),%ecx
cmp    $0xffffffff,%ecx
mov    %r9d,0x88(%rsp)
je     11df <jerasure_generate_decoding_schedule+0x5f>
lea    0x4(%r14),%rax
xor    %edi,%edi
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
xor    %esi,%esi
cmp    %ebp,%ecx
setge  %dl
setl   %sil
add    %esi,%r13d
add    %edx,%edi
mov    (%rax),%ecx
add    $0x4,%rax
cmp    $0xffffffff,%ecx
jne    11c0 <jerasure_generate_decoding_schedule+0x40>
jmp    11e4 <jerasure_generate_decoding_schedule+0x64>
xor    %r13d,%r13d
xor    %edi,%edi
mov    %rdi,0x60(%rsp)
lea    (%rbx,%rbp,1),%r12d
shl    $0x2,%r12d
mov    %r12d,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %r12d,%edi
call   1070 <malloc@plt>
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r14,%rdx
mov    %r15,0x28(%rsp)
mov    %r15,%rcx
mov    %rax,0xa8(%rsp)
mov    %rax,%r8
call   1040 <set_up_ids_for_scheduled_decoding@plt>
test   %rax,%rax
js     19df <jerasure_generate_decoding_schedule+0x85f>
mov    (%rsp),%rbx
mov    %ebx,%r12d
imul   %ebp,%r12d
mov    0x60(%rsp),%rax
add    %r13d,%eax
mov    %r12d,%r14d
imul   %ebx,%r14d
lea    0x0(,%r14,4),%edi
mov    %edi,0x14(%rsp)
mov    %eax,0x54(%rsp)
imul   %eax,%edi
call   1070 <malloc@plt>
mov    %rbx,%rcx
mov    %rax,%rbx
movslq %ebp,%rax
mov    %rax,0x98(%rsp)
mov    %r14,0x68(%rsp)
movslq %r14d,%rax
mov    %rax,0x18(%rsp)
mov    %ebp,%eax
mov    %rax,0x70(%rsp)
mov    %ecx,%eax
mov    %rax,0x48(%rsp)
test   %r13d,%r13d
mov    %rbx,0x40(%rsp)
mov    %rbp,0x20(%rsp)
je     1487 <jerasure_generate_decoding_schedule+0x307>
lea    0x0(,%r12,4),%eax
mov    %eax,0x80(%rsp)
mov    %eax,%edi
imul   %r12d,%edi
mov    %edi,0x78(%rsp)
call   1070 <malloc@plt>
mov    0x48(%rsp),%rcx
mov    %rax,0x30(%rsp)
test   %ebp,%ebp
jle    13ce <jerasure_generate_decoding_schedule+0x24e>
mov    %ecx,%ebx
and    $0xfffffffe,%ebx
lea    0x1(%r12),%esi
lea    (%r12,%r12,1),%edi
add    $0x2,%edi
xor    %ebp,%ebp
xor    %r14d,%r14d
mov    0x30(%rsp),%r15
mov    %rsi,0x38(%rsp)
mov    %edi,0x8(%rsp)
jmp    133f <jerasure_generate_decoding_schedule+0x1bf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    0x20(%rsp),%eax
imul   0x68(%rsp),%eax
cltq
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
mov    %r15,%rdi
mov    0x14(%rsp),%edx
call   1060 <memcpy@plt>
mov    (%rsp),%r9
mov    0x18(%rsp),%rax
lea    (%r15,%rax,4),%r15
add    $0x1,%r14
add    %r9d,%ebp
cmp    0x70(%rsp),%r14
je     13ce <jerasure_generate_decoding_schedule+0x24e>
mov    0x28(%rsp),%rax
mov    (%rax,%r14,4),%eax
cmp    %rax,%r14
jne    1300 <jerasure_generate_decoding_schedule+0x180>
mov    %r15,%rdi
mov    0x14(%rsp),%esi
call   1090 <bzero@plt>
mov    (%rsp),%r9
test   %r9d,%r9d
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%rsi
mov    0x8(%rsp),%edi
jle    1324 <jerasure_generate_decoding_schedule+0x1a4>
cmp    $0x1,%r9d
jne    137a <jerasure_generate_decoding_schedule+0x1fa>
xor    %eax,%eax
jmp    13a4 <jerasure_generate_decoding_schedule+0x224>
mov    %ebp,%ecx
xor    %eax,%eax
xchg   %ax,%ax
movslq %ecx,%rcx
movl   $0x1,(%r15,%rcx,4)
lea    (%rsi,%rcx,1),%edx
movslq %edx,%rdx
movl   $0x1,(%r15,%rdx,4)
add    $0x2,%rax
add    %edi,%ecx
cmp    %rax,%rbx
jne    1380 <jerasure_generate_decoding_schedule+0x200>
test   $0x1,%r8b
je     1324 <jerasure_generate_decoding_schedule+0x1a4>
mov    %eax,%ecx
imul   0x20(%rsp),%ecx
add    %r14d,%ecx
imul   %r9d,%ecx
add    %eax,%ecx
movslq %ecx,%rax
movl   $0x1,(%r15,%rax,4)
jmp    1324 <jerasure_generate_decoding_schedule+0x1a4>
mov    0x78(%rsp),%edi
call   1070 <malloc@plt>
mov    0x30(%rsp),%rbx
mov    %rbx,%rdi
mov    %rax,0x38(%rsp)
mov    %rax,%rsi
mov    %r12d,%edx
call   1080 <jerasure_invert_bitmatrix@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%ebx
imul   (%rsp),%ebx
cmp    $0x2,%r13d
mov    $0x1,%eax
cmovae %r13d,%eax
mov    %rax,0x8(%rsp)
mov    0x28(%rsp),%rax
mov    0x98(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
mov    %rax,0x30(%rsp)
mov    0x18(%rsp),%rcx
lea    0x0(,%rcx,4),%rbp
xor    %r15d,%r15d
mov    0x40(%rsp),%r14
nop
mov    0x30(%rsp),%rax
movslq (%rax,%r15,4),%rax
imul   %rcx,%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
mov    %r14,%rdi
mov    %ebx,%edx
call   1060 <memcpy@plt>
mov    0x18(%rsp),%rcx
add    $0x1,%r15
add    %rbp,%r14
cmp    %r15,0x8(%rsp)
jne    1440 <jerasure_generate_decoding_schedule+0x2c0>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rbp
mov    0x40(%rsp),%rbx
mov    0x60(%rsp),%rdx
test   %edx,%edx
mov    0x58(%rsp),%r15
je     19c1 <jerasure_generate_decoding_schedule+0x841>
mov    (%rsp),%rax
lea    0x0(,%rax,4),%ecx
mov    %ecx,0x90(%rsp)
cltq
mov    %rax,0x108(%rsp)
movslq %r13d,%rcx
mov    %edx,%eax
mov    %rax,0xe8(%rsp)
mov    %r12d,%r13d
mov    %rcx,%rax
mov    %rcx,0xf0(%rsp)
mov    0x18(%rsp),%rax
imul   %rax,%rcx
lea    (%rcx,%r13,1),%rdx
mov    %rdx,0xd0(%rsp)
lea    (%rbx,%r13,4),%rdx
mov    %rdx,0x100(%rsp)
mov    %r13d,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x80(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x78(%rsp)
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,0x140(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x130(%rsp)
mov    %r13,%rdx
neg    %rdx
mov    %rdx,0x38(%rsp)
lea    (%rbx,%rcx,4),%rdx
mov    %rdx,0xc0(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0xe0(%rsp)
lea    0x30(%rbx),%rax
mov    %rax,0xf8(%rsp)
mov    %rcx,0xd8(%rsp)
lea    (%rbx,%rcx,4),%rax
add    $0x4,%rax
mov    %rax,0xb8(%rsp)
xor    %ecx,%ecx
jmp    15bc <jerasure_generate_decoding_schedule+0x43c>
nopl   0x0(%rax)
mov    0xa0(%rsp),%rcx
add    $0x1,%rcx
mov    0xe0(%rsp),%rax
add    %rax,0xc0(%rsp)
add    %rax,0xb8(%rsp)
cmp    0xe8(%rsp),%rcx
mov    0x20(%rsp),%rbp
mov    0x40(%rsp),%rbx
je     19c1 <jerasure_generate_decoding_schedule+0x841>
mov    0xf0(%rsp),%rax
mov    %rcx,0xa0(%rsp)
add    %rcx,%rax
mov    0x98(%rsp),%rcx
add    %rax,%rcx
mov    0x28(%rsp),%rdx
mov    (%rdx,%rcx,4),%ecx
sub    %ebp,%ecx
imul   0x18(%rsp),%rax
lea    (%rbx,%rax,4),%rdi
imul   0x68(%rsp),%ecx
mov    %ecx,0x8c(%rsp)
movslq %ecx,%rax
lea    (%r15,%rax,4),%rsi
mov    %rdi,0xc8(%rsp)
mov    0x14(%rsp),%edx
call   1060 <memcpy@plt>
test   %ebp,%ebp
jle    1580 <jerasure_generate_decoding_schedule+0x400>
mov    0xa0(%rsp),%rax
imul   0x18(%rsp),%rax
mov    0xd8(%rsp),%rcx
add    %rax,%rcx
add    0xd0(%rsp),%rax
mov    0x40(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %rcx,0x118(%rsp)
lea    (%rdx,%rax,4),%rax
mov    %rax,0x110(%rsp)
xor    %ecx,%ecx
jmp    1670 <jerasure_generate_decoding_schedule+0x4f0>
nopl   0x0(%rax)
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
cmp    0x70(%rsp),%rcx
je     16e0 <jerasure_generate_decoding_schedule+0x560>
mov    0x28(%rsp),%rax
mov    (%rax,%rcx,4),%eax
mov    %rcx,0x8(%rsp)
cmp    %rax,%rcx
mov    0x90(%rsp),%r14d
je     1660 <jerasure_generate_decoding_schedule+0x4e0>
cmpl   $0x0,(%rsp)
jle    1660 <jerasure_generate_decoding_schedule+0x4e0>
mov    0x8(%rsp),%rax
imul   0x108(%rsp),%rax
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rax,4),%r15
xor    %ebp,%ebp
mov    0x48(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%r15,%rbp,4),%rdi
mov    %r14d,%esi
call   1090 <bzero@plt>
add    %r12d,%ebp
add    $0xffffffffffffffff,%rbx
jne    16c0 <jerasure_generate_decoding_schedule+0x540>
jmp    1660 <jerasure_generate_decoding_schedule+0x4e0>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x20(%rsp)
mov    0x58(%rsp),%r15
mov    0x48(%rsp),%r9
jle    1580 <jerasure_generate_decoding_schedule+0x400>
xor    %ecx,%ecx
jmp    1717 <jerasure_generate_decoding_schedule+0x597>
nopl   0x0(%rax)
mov    0xb0(%rsp),%rcx
add    $0x1,%rcx
cmp    0x70(%rsp),%rcx
je     1580 <jerasure_generate_decoding_schedule+0x400>
mov    0x28(%rsp),%rax
mov    (%rax,%rcx,4),%eax
mov    %rcx,0xb0(%rsp)
cmp    %rax,%rcx
je     1700 <jerasure_generate_decoding_schedule+0x580>
cmpl   $0x0,(%rsp)
jle    1700 <jerasure_generate_decoding_schedule+0x580>
mov    0xa8(%rsp),%rax
mov    0xb0(%rsp),%rdx
mov    (%rax,%rdx,4),%eax
sub    0x20(%rsp),%eax
imul   0x68(%rsp),%eax
cltq
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
imul   (%rsp),%edx
add    0x8c(%rsp),%edx
mov    %edx,0x94(%rsp)
mov    0x100(%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
mov    %rdx,0x30(%rsp)
mov    0xf8(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    %rax,0x138(%rsp)
xor    %eax,%eax
xor    %esi,%esi
jmp    17c0 <jerasure_generate_decoding_schedule+0x640>
cs nopw 0x0(%rax,%rax,1)
mov    0x120(%rsp),%rsi
add    $0x1,%rsi
mov    0x128(%rsp),%rax
add    %r12d,%eax
cmp    %r9,%rsi
je     1700 <jerasure_generate_decoding_schedule+0x580>
mov    %rax,0x128(%rsp)
cltq
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,4),%rdi
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    %r12d,%edx
mov    %rsi,0x120(%rsp)
imul   %esi,%edx
movslq %edx,%r8
mov    0x118(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
mov    %rdx,0x8(%rsp)
mov    0x110(%rsp),%rdx
lea    (%rdx,%r8,4),%rdx
mov    %rdx,0x60(%rsp)
mov    0xc8(%rsp),%rdx
lea    (%rdx,%r8,4),%r14
add    0x94(%rsp),%r8d
xor    %r11d,%r11d
xor    %r10d,%r10d
jmp    1850 <jerasure_generate_decoding_schedule+0x6d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r12d,%r11d
cmp    %r9,%r10
je     17a0 <jerasure_generate_decoding_schedule+0x620>
lea    (%r8,%r10,1),%edx
movslq %edx,%rdx
cmpl   $0x0,(%r15,%rdx,4)
je     1840 <jerasure_generate_decoding_schedule+0x6c0>
test   %r12d,%r12d
jle    1840 <jerasure_generate_decoding_schedule+0x6c0>
movslq %r11d,%rsi
mov    %r12d,%edx
imul   %r10d,%edx
movslq %edx,%rdx
cmp    $0x8,%r12d
jb     1891 <jerasure_generate_decoding_schedule+0x711>
mov    0x30(%rsp),%rbx
lea    (%rbx,%rdx,4),%rbp
cmp    %rbp,0x8(%rsp)
jae    18dc <jerasure_generate_decoding_schedule+0x75c>
lea    (%rcx,%rdx,4),%rbp
cmp    0x60(%rsp),%rbp
jae    18dc <jerasure_generate_decoding_schedule+0x75c>
xor    %ebx,%ebx
mov    %rbx,%rbp
test   $0x1,%r13b
je     18ad <jerasure_generate_decoding_schedule+0x72d>
add    %rbx,%rdx
mov    (%rcx,%rdx,4),%edx
xor    %edx,(%r14,%rbx,4)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    0x38(%rsp),%rbx
je     1840 <jerasure_generate_decoding_schedule+0x6c0>
lea    (%rcx,%rsi,4),%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rbp,4),%esi
xor    %esi,-0x4(%rdi,%rbp,4)
mov    0x4(%rdx,%rbp,4),%esi
xor    %esi,(%rdi,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%r13
jne    18c0 <jerasure_generate_decoding_schedule+0x740>
jmp    1840 <jerasure_generate_decoding_schedule+0x6c0>
cmpq   $0x0,0x78(%rsp)
je     19b2 <jerasure_generate_decoding_schedule+0x832>
mov    0x138(%rsp),%rbp
lea    0x0(%rbp,%rsi,4),%rbp
mov    0x130(%rsp),%r9
xor    %r15d,%r15d
movups -0x30(%rbp,%r15,4),%xmm0
movups -0x20(%rbp,%r15,4),%xmm1
movups (%rax,%r15,4),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rax,%r15,4),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rax,%r15,4),%xmm1
movups 0x30(%rax,%r15,4),%xmm3
movups %xmm2,(%rax,%r15,4)
movups %xmm0,0x10(%rax,%r15,4)
movups -0x10(%rbp,%r15,4),%xmm0
xorps  %xmm1,%xmm0
movups 0x0(%rbp,%r15,4),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rax,%r15,4)
movups %xmm1,0x30(%rax,%r15,4)
add    $0x10,%r15
add    $0xfffffffffffffffe,%r9
jne    1900 <jerasure_generate_decoding_schedule+0x780>
testb  $0x1,0x140(%rsp)
01
je     198f <jerasure_generate_decoding_schedule+0x80f>
movups (%r14,%r15,4),%xmm0
movups 0x10(%r14,%r15,4),%xmm1
lea    (%r15,%rdx,1),%rbp
movups (%rcx,%rbp,4),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rcx,%rbp,4),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%r14,%r15,4)
movups %xmm0,0x10(%r14,%r15,4)
mov    0x80(%rsp),%rbp
mov    %rbp,%rbx
cmp    %r13,%rbp
mov    0x58(%rsp),%r15
mov    0x48(%rsp),%r9
je     1840 <jerasure_generate_decoding_schedule+0x6c0>
jmp    1893 <jerasure_generate_decoding_schedule+0x713>
xor    %r15d,%r15d
testb  $0x1,0x140(%rsp)
01
jne    1966 <jerasure_generate_decoding_schedule+0x7e6>
jmp    198f <jerasure_generate_decoding_schedule+0x80f>
cmpl   $0x0,0x88(%rsp)
je     19e3 <jerasure_generate_decoding_schedule+0x863>
mov    %ebp,%edi
mov    0x54(%rsp),%esi
mov    (%rsp),%rdx
mov    %rbx,%rcx
call   1050 <jerasure_smart_bitmatrix_to_schedule@plt>
jmp    19f5 <jerasure_generate_decoding_schedule+0x875>
xor    %ebp,%ebp
jmp    1a17 <jerasure_generate_decoding_schedule+0x897>
mov    %ebp,%edi
mov    0x54(%rsp),%esi
mov    (%rsp),%rdx
mov    %rbx,%rcx
call   10a0 <jerasure_dumb_bitmatrix_to_schedule@plt>
mov    %rax,%rbp
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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