int **mls(unsigned n, unsigned *mls_size, char is_full) {
  unsigned i, j, k;
  unsigned N2 = 1 << (n + 1);
  unsigned N = 1 << n;
  char *flag = malloc(sizeof(char) * N2);
  unsigned irr_num = 0;
  unsigned mls_num = 0;
  unsigned *irr;
  int **mseqes;
  int *mp;
  for (i = 1; i < N2; i++)
    flag[i] = 1;
  flag[1] = 0;
  for (i = 2; mul(i, i) < N2; i++)
    if (flag[i] == 1)
      for (j = i; mul(i, j) < N2; j++)
        flag[mul(i, j)] = 0;
  for (i = N + 1; i < N2; i++)
    if (flag[i])
      irr_num++;
  irr = malloc(sizeof(unsigned) * irr_num);
  irr_num = 0;
  for (i = N + 1; i < N2; i++)
    if (flag[i])
      irr[irr_num++] = i;
  free(flag);
  mp = malloc(sizeof(int) * irr_num * (N - 1));
  for (i = 0; i < irr_num; i++) {
    unsigned f = irr[i] >> 1;
    unsigned lfsr = 1;
    int *tmp = mp + mls_num * (N - 1);
    for (k = 0; k < N - 1; k++) {
      lfsr = (lfsr >> 1) ^ (-(lfsr & 1) & f);
      tmp[k] = (lfsr & 1) ? 1 : -1;
      if (lfsr == 1)
        break;
    }
    if (k == N - 2) {
      mls_num++;
      if (!is_full)
        break;
    }
  }
  mp = realloc(mp, sizeof(int) * mls_num * (N - 1));
  mseqes = malloc(sizeof(int *) * mls_num);
  for (i = 0; i < mls_num; i++)
    mseqes[i] = mp + i * (N - 1);
  free(irr);
  *mls_size = mls_num;
  return mseqes;
}


x86 assembly (clang, -O0):
<mls>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %dl,%al
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %al,-0x11(%rbp)
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%edi
shl    $0x0,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    11bd <mls+0x7d>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1198 <mls+0x58>
mov    -0x30(%rbp),%rax
movb   $0x0,0x1(%rax)
movl   $0x2,-0x18(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    $0x0,%al
call   1060 <mul@plt>
cmp    -0x24(%rbp),%eax
jae    125a <mls+0x11a>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x1,%eax
jne    1247 <mls+0x107>
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    $0x0,%al
call   1060 <mul@plt>
cmp    -0x24(%rbp),%eax
jae    1242 <mls+0x102>
mov    -0x30(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    $0x0,%al
call   1060 <mul@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11fc <mls+0xbc>
jmp    1247 <mls+0x107>
jmp    124c <mls+0x10c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11cc <mls+0x8c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    129c <mls+0x15c>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     1289 <mls+0x149>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128e <mls+0x14e>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1263 <mls+0x123>
mov    -0x34(%rbp),%eax
mov    %eax,%edi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1305 <mls+0x1c5>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     12f2 <mls+0x1b2>
mov    -0x18(%rbp),%edx
mov    -0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
jmp    12f7 <mls+0x1b7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12be <mls+0x17e>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
mov    %eax,%edi
shl    $0x2,%rdi
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
imul   %rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    1426 <mls+0x2e6>
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
shr    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    13e5 <mls+0x2a5>
mov    -0x58(%rbp),%eax
shr    $0x1,%eax
mov    -0x58(%rbp),%edx
and    $0x1,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
and    -0x54(%rbp),%ecx
xor    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%ecx
and    $0x1,%ecx
mov    $0xffffffff,%edx
mov    $0x1,%eax
cmp    $0x0,%ecx
cmovne %eax,%edx
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x58(%rbp)
jne    13d2 <mls+0x292>
jmp    13e5 <mls+0x2a5>
jmp    13d7 <mls+0x297>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    137a <mls+0x23a>
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jne    1413 <mls+0x2d3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpb   $0x0,-0x11(%rbp)
jne    140e <mls+0x2ce>
jmp    1426 <mls+0x2e6>
jmp    1413 <mls+0x2d3>
jmp    1418 <mls+0x2d8>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1333 <mls+0x1f3>
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%eax
mov    %eax,%esi
shl    $0x2,%rsi
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
imul   %rax,%rsi
call   1050 <realloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x38(%rbp),%eax
jae    149f <mls+0x35f>
mov    -0x50(%rbp),%rdx
mov    -0x18(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,%eax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1461 <mls+0x321>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mls>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,0x1c(%rsp)
mov    %rsi,0x20(%rsp)
mov    %edi,%ebx
lea    0x1(%rbx),%ecx
mov    $0x1,%r14d
shl    %cl,%r14d
mov    $0x1,%r15d
mov    %ebx,%ecx
shl    %cl,%r15d
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
inc    %ebx
je     11ad <mls+0x5d>
lea    0x1(%r13),%rdi
cmp    $0x3,%r14d
mov    $0x2,%edx
cmovae %r14d,%edx
add    $0xffffffff,%edx
mov    $0x1,%esi
call   1040 <memset@plt>
movb   $0x0,0x1(%r13)
mov    $0x2,%ebp
mov    $0x2,%edi
mov    $0x2,%esi
jmp    11d7 <mls+0x87>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebp
mov    %ebp,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1070 <mul@plt>
cmp    %r14d,%eax
jae    1228 <mls+0xd8>
mov    %ebp,%eax
cmpb   $0x1,0x0(%r13,%rax,1)
jne    11d0 <mls+0x80>
mov    %ebp,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1070 <mul@plt>
cmp    %r14d,%eax
jae    11d0 <mls+0x80>
mov    %ebp,%ebx
nop
mov    %ebp,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <mul@plt>
cltq
movb   $0x0,0x0(%r13,%rax,1)
add    $0x1,%ebx
mov    %ebp,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <mul@plt>
cmp    %r14d,%eax
jb     1200 <mls+0xb0>
jmp    11d0 <mls+0x80>
lea    0x1(%r15),%r12d
cmp    %r14d,%r12d
mov    %r15,0x8(%rsp)
jae    1251 <mls+0x101>
mov    %r12d,%ebx
mov    %r14d,%ebp
sub    %r15d,%ebp
add    $0xfffffffe,%ebp
xor    %ecx,%ecx
cmp    $0x7,%ebp
jae    1264 <mls+0x114>
mov    %rbx,%rax
jmp    13ad <mls+0x25d>
xor    %ebp,%ebp
xor    %edi,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
jmp    1467 <mls+0x317>
lea    0x1(%rbp),%r8
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1437 <mls+0x2e7>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rbx,%r13,1),%rcx
add    $0xc,%rcx
pxor   %xmm2,%xmm2
xor    %esi,%esi
pcmpeqd %xmm3,%xmm3
movdqa 0xd58(%rip),%xmm4
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
movd   -0xc(%rcx,%rsi,1),%xmm6
movd   -0x8(%rcx,%rsi,1),%xmm5
pcmpeqb %xmm2,%xmm6
pxor   %xmm3,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
pand   %xmm4,%xmm6
paddd  %xmm0,%xmm6
pcmpeqb %xmm2,%xmm5
pxor   %xmm3,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm4,%xmm5
paddd  %xmm1,%xmm5
movd   -0x4(%rcx,%rsi,1),%xmm0
movd   (%rcx,%rsi,1),%xmm1
pcmpeqb %xmm2,%xmm0
pxor   %xmm3,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm4,%xmm0
paddd  %xmm6,%xmm0
pcmpeqb %xmm2,%xmm1
pxor   %xmm3,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm4,%xmm1
paddd  %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12b0 <mls+0x160>
test   $0x1,%dl
je     138b <mls+0x23b>
add    %rbx,%rsi
movd   0x0(%r13,%rsi,1),%xmm2
movd   0x4(%r13,%rsi,1),%xmm3
pxor   %xmm4,%xmm4
pcmpeqb %xmm4,%xmm2
pcmpeqd %xmm5,%xmm5
pxor   %xmm5,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movdqa 0xc95(%rip),%xmm6
pand   %xmm6,%xmm2
paddd  %xmm2,%xmm0
pcmpeqb %xmm4,%xmm3
pxor   %xmm5,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm6,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
cmp    %rax,%r8
je     13c1 <mls+0x271>
add    %rbx,%rax
mov    %r14d,%edx
cmpb   $0x1,0x0(%r13,%rax,1)
sbb    $0xffffffff,%ecx
add    $0x1,%rax
cmp    %eax,%edx
jne    13b0 <mls+0x260>
mov    %ecx,%edi
shl    $0x2,%rdi
call   1050 <malloc@plt>
cmp    %r14d,%r12d
mov    %rax,0x10(%rsp)
jae    142e <mls+0x2de>
mov    0x8(%rsp),%r15
mov    %r15d,%ecx
not    %ecx
add    %ecx,%r14d
test   %ebp,%ebp
je     144f <mls+0x2ff>
mov    %r14d,%esi
and    $0xfffffffe,%esi
lea    0x2(%r15),%ecx
xor    %ebp,%ebp
jmp    140c <mls+0x2bc>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rbx
add    $0x2,%ecx
add    $0xfffffffe,%esi
je     1451 <mls+0x301>
cmpb   $0x0,0x0(%r13,%rbx,1)
je     141c <mls+0x2cc>
mov    %ebp,%edx
add    $0x1,%ebp
mov    %ebx,(%rax,%rdx,4)
cmpb   $0x0,0x1(%r13,%rbx,1)
je     1400 <mls+0x2b0>
mov    %ebp,%edx
add    $0x1,%ebp
mov    %ecx,(%rax,%rdx,4)
jmp    1400 <mls+0x2b0>
xor    %ebp,%ebp
mov    0x8(%rsp),%r15
jmp    1467 <mls+0x317>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    133a <mls+0x1ea>
jmp    138b <mls+0x23b>
xor    %ebp,%ebp
test   $0x1,%r14b
je     1467 <mls+0x317>
cmpb   $0x0,0x0(%r13,%rbx,1)
je     1467 <mls+0x317>
mov    %ebp,%ecx
add    $0x1,%ebp
mov    %ebx,(%rax,%rcx,4)
mov    %r13,%rdi
call   1030 <free@plt>
mov    %ebp,%r13d
lea    -0x1(%r15),%r12d
lea    0x0(,%r12,4),%r14
mov    %r14,%rdi
imul   %r13,%rdi
call   1050 <malloc@plt>
test   %ebp,%ebp
je     1520 <mls+0x3d0>
lea    -0x2(%r15),%r8d
xor    %edx,%edx
xor    %r15d,%r15d
mov    0x1c(%rsp),%r9d
mov    0x10(%rsp),%r10
jmp    14b9 <mls+0x369>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r13,%rdx
je     1523 <mls+0x3d3>
mov    $0x0,%edi
test   %r12,%r12
je     1510 <mls+0x3c0>
mov    (%r10,%rdx,4),%esi
shr    %esi
mov    %r15d,%ecx
imul   %r12d,%ecx
lea    (%rax,%rcx,4),%rbp
mov    $0x1,%ebx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    %ebx,%ecx
shr    %ecx
and    $0x1,%ebx
neg    %ebx
and    %esi,%ebx
xor    %ecx,%ebx
mov    %ebx,%ecx
and    $0x1,%ecx
cmp    $0x1,%ecx
sbb    %ecx,%ecx
or     $0x1,%ecx
mov    %ecx,0x0(%rbp,%rdi,4)
cmp    $0x1,%ebx
je     1510 <mls+0x3c0>
add    $0x1,%rdi
cmp    %rdi,%r12
jne    14e0 <mls+0x390>
jmp    14b0 <mls+0x360>
xchg   %ax,%ax
cmp    %r8d,%edi
jne    14b0 <mls+0x360>
add    $0x1,%r15d
test   %r9b,%r9b
jne    14b0 <mls+0x360>
jmp    1523 <mls+0x3d3>
xor    %r15d,%r15d
mov    %r15d,%r13d
imul   %r13,%r14
mov    %rax,%rdi
mov    %r14,%rsi
call   1060 <realloc@plt>
mov    %rax,%rbp
lea    0x0(,%r13,8),%rdi
call   1050 <malloc@plt>
mov    0x10(%rsp),%rdi
mov    %rax,%r14
test   %r15d,%r15d
je     160d <mls+0x4bd>
lea    -0x1(%r13),%rax
mov    %r13d,%r8d
and    $0x3,%r8d
xor    %edx,%edx
cmp    $0x3,%rax
jae    156d <mls+0x41d>
xor    %ecx,%ecx
jmp    15db <mls+0x48b>
and    $0xfffffffc,%r13d
mov    0x8(%rsp),%rax
lea    (%rax,%rax,1),%r9d
add    $0xfffffffe,%r9d
lea    -0x4(,%rax,4),%esi
lea    (%rax,%rax,2),%eax
add    $0xfffffffd,%eax
xor    %ecx,%ecx
nopl   (%rax)
mov    %edx,%ebx
lea    0x0(,%rbx,4),%rbx
add    %rbp,%rbx
mov    %rbx,(%r14,%rcx,8)
lea    (%r12,%rdx,1),%ebx
lea    0x0(%rbp,%rbx,4),%rbx
mov    %rbx,0x8(%r14,%rcx,8)
lea    (%r9,%rdx,1),%ebx
lea    0x0(%rbp,%rbx,4),%rbx
mov    %rbx,0x10(%r14,%rcx,8)
lea    (%rax,%rdx,1),%ebx
lea    0x0(,%rbx,4),%rbx
add    %rbp,%rbx
mov    %rbx,0x18(%r14,%rcx,8)
add    $0x4,%rcx
add    %esi,%edx
cmp    %rcx,%r13
jne    1590 <mls+0x440>
test   %r8,%r8
je     160d <mls+0x4bd>
lea    (%r14,%rcx,8),%rax
imul   %r12d,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%esi
lea    0x0(,%rsi,4),%rsi
add    %rbp,%rsi
mov    %rsi,(%rax,%rdx,8)
add    $0x1,%rdx
add    %r12d,%ecx
cmp    %rdx,%r8
jne    15f0 <mls+0x4a0>
call   1030 <free@plt>
mov    0x20(%rsp),%rax
mov    %r15d,(%rax)
mov    %r14,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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