#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 *calloc(int, int);
int /*<<< orphan*/ free(int *);
int gcd(int, int);
void CreateUmtsInterleaver(int LL, int *input, int *output) {
  int RR, CC;
  int index, i, j, itemp;
  int pValue, vValue;
  int pTable[52] = {7,   11,  13,  17,  19,  23,  29,  31,  37,  41,  43,
                    47,  53,  59,  61,  67,  71,  73,  79,  83,  89,  97,
                    101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
                    157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
                    223, 227, 229, 233, 239, 241, 251, 257};
  int vTable[52] = {3, 2, 2, 3,  2, 5, 2, 3, 2, 6, 3, 5, 2, 2, 2, 2, 7, 5,
                    3, 2, 3, 5,  2, 5, 2, 6, 3, 3, 2, 3, 2, 2, 6, 5, 2, 5,
                    2, 2, 2, 19, 5, 2, 3, 2, 3, 2, 6, 3, 7, 7, 6, 3};
  int T5[5] = {4, 3, 2, 1, 0};
  int T10[10] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
  int T20a[20] = {19, 9,  14, 4,  0, 2, 5, 7,  12, 18,
                  16, 13, 17, 15, 3, 1, 6, 11, 8,  10};
  int T20b[20] = {19, 9, 14, 4,  0, 2, 5,  7, 12, 18,
                  10, 8, 13, 17, 3, 1, 16, 6, 15, 11};
  int *Matrix, *IntraMatrix, *InterMatrix, *s, *q, *r;
  if ((40 <= LL) && (LL <= 159)) {
    RR = 5;
  } else if ((160 <= LL) && (LL <= 200)) {
    RR = 10;
  } else if ((481 <= LL) && (LL <= 530)) {
    RR = 10;
  } else {
    RR = 20;
  }
  if ((481 <= LL) && (LL <= 530)) {
    pValue = 53;
    CC = pValue;
    vValue = 2;
  } else {
    for (index = 0; index < 52; index++) {
      if (LL <= RR * (pTable[index] + 1)) {
        break;
      }
    }
    pValue = pTable[index];
    vValue = vTable[index];
    if (LL <= RR * (pValue - 1)) {
      CC = pValue - 1;
    } else if (RR * pValue < LL) {
      CC = pValue + 1;
    } else {
      CC = pValue;
    }
  }
  Matrix = calloc(RR * CC, sizeof(int));
  InterMatrix = calloc(RR * CC, sizeof(int));
  IntraMatrix = calloc(RR * CC, sizeof(int));
  index = 0;
  for (i = 0; i < RR; i++) {
    for (j = 0; j < CC; j++) {
      if (index < LL) {
        Matrix[i + j * RR] = input[index];
      } else {
        Matrix[i + j * RR] = -1;
      }
      index++;
    }
  }
  s = calloc(pValue - 1, sizeof(int));
  s[0] = 1;
  for (j = 1; j < pValue - 1; j++) {
    s[j] = (vValue * s[j - 1]) % pValue;
  }
  q = calloc(RR, sizeof(int));
  q[0] = 1;
  index = 0;
  for (i = 1; i < RR; i++) {
    itemp = index;
    for (index = itemp; index < 52; index++) {
      if ((gcd(pTable[index], pValue - 1) == 1) && (pTable[index] > q[i - 1])) {
        q[i] = pTable[index];
        break;
      }
    }
  }
  r = calloc(RR, sizeof(int));
  if (RR == 5) {
    for (i = 0; i < RR; i++) {
      r[T5[i]] = q[i];
    }
  } else if (RR == 10) {
    for (i = 0; i < RR; i++) {
      r[T10[i]] = q[i];
    }
  } else if (((2281 <= LL) && (LL <= 2480)) || ((3161 <= LL) && (LL <= 3210))) {
    for (i = 0; i < RR; i++) {
      r[T20a[i]] = q[i];
    }
  } else {
    for (i = 0; i < RR; i++) {
      r[T20b[i]] = q[i];
    }
  }
  for (i = 0; i < RR; i++) {
    if (CC == pValue) {
      for (j = 0; j <= pValue - 2; j++) {
        index = s[(j * r[i]) % (pValue - 1)];
        IntraMatrix[i + j * RR] = Matrix[i + index * RR];
      }
      IntraMatrix[i + (pValue - 1) * RR] = Matrix[i];
    } else if (CC == pValue + 1) {
      for (j = 0; j <= pValue - 2; j++) {
        index = s[(j * r[i]) % (pValue - 1)];
        IntraMatrix[i + j * RR] = Matrix[i + index * RR];
      }
      IntraMatrix[i + (pValue - 1) * RR] = Matrix[i];
      IntraMatrix[i + pValue * RR] = Matrix[i + pValue * RR];
      if ((LL == RR * CC) && (i == RR - 1)) {
        itemp = IntraMatrix[RR - 1];
        IntraMatrix[RR - 1] = IntraMatrix[(RR - 1) + RR * pValue];
        IntraMatrix[(RR - 1) + RR * pValue] = itemp;
      }
    } else {
      for (j = 0; j <= pValue - 2; j++) {
        index = s[(j * r[i]) % (pValue - 1)] - 1;
        IntraMatrix[i + j * RR] = Matrix[i + index * RR];
      }
    }
  }
  for (i = 0; i < RR; i++) {
    if (RR == 5) {
      index = T5[i];
    } else if (RR == 10) {
      index = T10[i];
    } else if (((2281 <= LL) && (LL <= 2480)) ||
               ((3161 <= LL) && (LL <= 3210))) {
      index = T20a[i];
    } else {
      index = T20b[i];
    }
    for (j = 0; j < CC; j++) {
      InterMatrix[i + j * RR] = IntraMatrix[index + j * RR];
    }
  }
  index = 0;
  for (j = 0; j < CC; j++) {
    for (i = 0; i < RR; i++) {
      if (InterMatrix[i + j * RR] >= 0) {
        output[index] = InterMatrix[i + j * RR];
        index++;
      }
    }
  }
  free(Matrix);
  free(InterMatrix);
  free(IntraMatrix);
  free(s);
  free(q);
  free(r);
}


x86 assembly (clang, -O0):
<CreateUmtsInterleaver>:
push   %rbp
mov    %rsp,%rbp
sub    $0x320,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x110(%rbp),%rdi
lea    0xe9c(%rip),%rsi
mov    $0xd0,%edx
call   1050 <memcpy@plt>
lea    -0x1e0(%rbp),%rdi
lea    0xf54(%rip),%rsi
mov    $0xd0,%edx
call   1050 <memcpy@plt>
mov    0x10b3(%rip),%rax
mov    %rax,-0x200(%rbp)
mov    0x10ad(%rip),%rax
mov    %rax,-0x1f8(%rbp)
mov    0x10a8(%rip),%eax
mov    %eax,-0x1f0(%rbp)
lea    -0x230(%rbp),%rdi
lea    0x10a4(%rip),%rsi
mov    $0x28,%edx
call   1050 <memcpy@plt>
lea    -0x280(%rbp),%rdi
lea    0xfcc(%rip),%rsi
mov    $0x50,%edx
call   1050 <memcpy@plt>
lea    -0x2d0(%rbp),%rdi
lea    0x1004(%rip),%rsi
mov    $0x50,%edx
call   1050 <memcpy@plt>
mov    $0x28,%eax
cmp    -0x4(%rbp),%eax
jg     121d <CreateUmtsInterleaver+0xdd>
cmpl   $0x9f,-0x4(%rbp)
jg     121d <CreateUmtsInterleaver+0xdd>
movl   $0x5,-0x1c(%rbp)
jmp    127c <CreateUmtsInterleaver+0x13c>
mov    $0xa0,%eax
cmp    -0x4(%rbp),%eax
jg     1244 <CreateUmtsInterleaver+0x104>
cmpl   $0xc8,-0x4(%rbp)
jg     1244 <CreateUmtsInterleaver+0x104>
movl   $0xa,-0x1c(%rbp)
jmp    1277 <CreateUmtsInterleaver+0x137>
mov    $0x1e1,%eax
cmp    -0x4(%rbp),%eax
jg     126b <CreateUmtsInterleaver+0x12b>
cmpl   $0x212,-0x4(%rbp)
jg     126b <CreateUmtsInterleaver+0x12b>
movl   $0xa,-0x1c(%rbp)
jmp    1272 <CreateUmtsInterleaver+0x132>
movl   $0x14,-0x1c(%rbp)
jmp    1277 <CreateUmtsInterleaver+0x137>
jmp    127c <CreateUmtsInterleaver+0x13c>
mov    $0x1e1,%eax
cmp    -0x4(%rbp),%eax
jg     12b0 <CreateUmtsInterleaver+0x170>
cmpl   $0x212,-0x4(%rbp)
jg     12b0 <CreateUmtsInterleaver+0x170>
movl   $0x35,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x2,-0x38(%rbp)
jmp    1367 <CreateUmtsInterleaver+0x227>
movl   $0x0,-0x24(%rbp)
cmpl   $0x34,-0x24(%rbp)
jge    12f8 <CreateUmtsInterleaver+0x1b8>
mov    -0x4(%rbp),%eax
mov    -0x1c(%rbp),%ecx
movslq -0x24(%rbp),%rdx
mov    -0x110(%rbp,%rdx,4),%edx
add    $0x1,%edx
imul   %edx,%ecx
cmp    %ecx,%eax
jg     12e5 <CreateUmtsInterleaver+0x1a5>
jmp    12f8 <CreateUmtsInterleaver+0x1b8>
jmp    12ea <CreateUmtsInterleaver+0x1aa>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b7 <CreateUmtsInterleaver+0x177>
movslq -0x24(%rbp),%rax
mov    -0x110(%rbp,%rax,4),%eax
mov    %eax,-0x34(%rbp)
movslq -0x24(%rbp),%rax
mov    -0x1e0(%rbp,%rax,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
cmp    %ecx,%eax
jg     1339 <CreateUmtsInterleaver+0x1f9>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1362 <CreateUmtsInterleaver+0x222>
mov    -0x1c(%rbp),%eax
imul   -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1357 <CreateUmtsInterleaver+0x217>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    135d <CreateUmtsInterleaver+0x21d>
mov    -0x34(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1362 <CreateUmtsInterleaver+0x222>
jmp    1367 <CreateUmtsInterleaver+0x227>
mov    -0x1c(%rbp),%edi
imul   -0x20(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x2d8(%rbp)
mov    -0x1c(%rbp),%edi
imul   -0x20(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x2e8(%rbp)
mov    -0x1c(%rbp),%edi
imul   -0x20(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x2e0(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1458 <CreateUmtsInterleaver+0x318>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1445 <CreateUmtsInterleaver+0x305>
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1411 <CreateUmtsInterleaver+0x2d1>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2d8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    142e <CreateUmtsInterleaver+0x2ee>
mov    -0x2d8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13d0 <CreateUmtsInterleaver+0x290>
jmp    144a <CreateUmtsInterleaver+0x30a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13bd <CreateUmtsInterleaver+0x27d>
mov    -0x34(%rbp),%edi
sub    $0x1,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x2f0(%rbp)
mov    -0x2f0(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14cb <CreateUmtsInterleaver+0x38b>
mov    -0x38(%rbp),%eax
mov    -0x2f0(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
cltd
idivl  -0x34(%rbp)
mov    -0x2f0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1483 <CreateUmtsInterleaver+0x343>
mov    -0x1c(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x2f8(%rbp)
mov    -0x2f8(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15a3 <CreateUmtsInterleaver+0x463>
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x34,-0x24(%rbp)
jge    1590 <CreateUmtsInterleaver+0x450>
movslq -0x24(%rbp),%rax
mov    -0x110(%rbp,%rax,4),%edi
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
call   1060 <gcd@plt>
cmp    $0x1,%eax
jne    157d <CreateUmtsInterleaver+0x43d>
movslq -0x24(%rbp),%rax
mov    -0x110(%rbp,%rax,4),%eax
mov    -0x2f8(%rbp),%rcx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    157d <CreateUmtsInterleaver+0x43d>
movslq -0x24(%rbp),%rax
mov    -0x110(%rbp,%rax,4),%edx
mov    -0x2f8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1590 <CreateUmtsInterleaver+0x450>
jmp    1582 <CreateUmtsInterleaver+0x442>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1512 <CreateUmtsInterleaver+0x3d2>
jmp    1595 <CreateUmtsInterleaver+0x455>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14fa <CreateUmtsInterleaver+0x3ba>
mov    -0x1c(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x300(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jne    160b <CreateUmtsInterleaver+0x4cb>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1606 <CreateUmtsInterleaver+0x4c6>
mov    -0x2f8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x300(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq -0x200(%rbp,%rcx,4),%rcx
ff
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15c8 <CreateUmtsInterleaver+0x488>
jmp    1733 <CreateUmtsInterleaver+0x5f3>
cmpl   $0xa,-0x1c(%rbp)
jne    165f <CreateUmtsInterleaver+0x51f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    165a <CreateUmtsInterleaver+0x51a>
mov    -0x2f8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x300(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq -0x230(%rbp,%rcx,4),%rcx
ff
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    161c <CreateUmtsInterleaver+0x4dc>
jmp    172e <CreateUmtsInterleaver+0x5ee>
mov    $0x8e9,%eax
cmp    -0x4(%rbp),%eax
jg     167a <CreateUmtsInterleaver+0x53a>
cmpl   $0x9b0,-0x4(%rbp)
jle    1695 <CreateUmtsInterleaver+0x555>
mov    $0xc59,%eax
cmp    -0x4(%rbp),%eax
jg     16df <CreateUmtsInterleaver+0x59f>
cmpl   $0xc8a,-0x4(%rbp)
jg     16df <CreateUmtsInterleaver+0x59f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16da <CreateUmtsInterleaver+0x59a>
mov    -0x2f8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x300(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq -0x280(%rbp,%rcx,4),%rcx
ff
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    169c <CreateUmtsInterleaver+0x55c>
jmp    1729 <CreateUmtsInterleaver+0x5e9>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1724 <CreateUmtsInterleaver+0x5e4>
mov    -0x2f8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x300(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq -0x2d0(%rbp,%rcx,4),%rcx
ff
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16e6 <CreateUmtsInterleaver+0x5a6>
jmp    1729 <CreateUmtsInterleaver+0x5e9>
jmp    172e <CreateUmtsInterleaver+0x5ee>
jmp    1733 <CreateUmtsInterleaver+0x5f3>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a4d <CreateUmtsInterleaver+0x90d>
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    1812 <CreateUmtsInterleaver+0x6d2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     17e3 <CreateUmtsInterleaver+0x6a3>
mov    -0x2f0(%rbp),%rax
mov    %rax,-0x308(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x300(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    -0x308(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2d8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1759 <CreateUmtsInterleaver+0x619>
mov    -0x2d8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a3a <CreateUmtsInterleaver+0x8fa>
mov    -0x20(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    199c <CreateUmtsInterleaver+0x85c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     18b4 <CreateUmtsInterleaver+0x774>
mov    -0x2f0(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x300(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    -0x310(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2d8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    182a <CreateUmtsInterleaver+0x6ea>
mov    -0x2d8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2d8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x34(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
cmp    %ecx,%eax
jne    1997 <CreateUmtsInterleaver+0x857>
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1997 <CreateUmtsInterleaver+0x857>
mov    -0x2e0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2e0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1c(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a35 <CreateUmtsInterleaver+0x8f5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1a30 <CreateUmtsInterleaver+0x8f0>
mov    -0x2f0(%rbp),%rax
mov    %rax,-0x318(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x300(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    -0x318(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2d8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e0(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19a3 <CreateUmtsInterleaver+0x863>
jmp    1a35 <CreateUmtsInterleaver+0x8f5>
jmp    1a3a <CreateUmtsInterleaver+0x8fa>
jmp    1a3f <CreateUmtsInterleaver+0x8ff>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    173a <CreateUmtsInterleaver+0x5fa>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b61 <CreateUmtsInterleaver+0xa21>
cmpl   $0x5,-0x1c(%rbp)
jne    1a7d <CreateUmtsInterleaver+0x93d>
movslq -0x28(%rbp),%rax
mov    -0x200(%rbp,%rax,4),%eax
mov    %eax,-0x24(%rbp)
jmp    1afb <CreateUmtsInterleaver+0x9bb>
cmpl   $0xa,-0x1c(%rbp)
jne    1a9a <CreateUmtsInterleaver+0x95a>
movslq -0x28(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%eax
mov    %eax,-0x24(%rbp)
jmp    1af6 <CreateUmtsInterleaver+0x9b6>
mov    $0x8e9,%eax
cmp    -0x4(%rbp),%eax
jg     1ab5 <CreateUmtsInterleaver+0x975>
cmpl   $0x9b0,-0x4(%rbp)
jle    1ad0 <CreateUmtsInterleaver+0x990>
mov    $0xc59,%eax
cmp    -0x4(%rbp),%eax
jg     1ae3 <CreateUmtsInterleaver+0x9a3>
cmpl   $0xc8a,-0x4(%rbp)
jg     1ae3 <CreateUmtsInterleaver+0x9a3>
movslq -0x28(%rbp),%rax
mov    -0x280(%rbp,%rax,4),%eax
mov    %eax,-0x24(%rbp)
jmp    1af1 <CreateUmtsInterleaver+0x9b1>
movslq -0x28(%rbp),%rax
mov    -0x2d0(%rbp,%rax,4),%eax
mov    %eax,-0x24(%rbp)
jmp    1af6 <CreateUmtsInterleaver+0x9b6>
jmp    1afb <CreateUmtsInterleaver+0x9bb>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1b4e <CreateUmtsInterleaver+0xa0e>
mov    -0x2e0(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x2e8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b02 <CreateUmtsInterleaver+0x9c2>
jmp    1b53 <CreateUmtsInterleaver+0xa13>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a54 <CreateUmtsInterleaver+0x914>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1c01 <CreateUmtsInterleaver+0xac1>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bee <CreateUmtsInterleaver+0xaae>
mov    -0x2e8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1bdb <CreateUmtsInterleaver+0xa9b>
mov    -0x2e8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1be0 <CreateUmtsInterleaver+0xaa0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1b82 <CreateUmtsInterleaver+0xa42>
jmp    1bf3 <CreateUmtsInterleaver+0xab3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b6f <CreateUmtsInterleaver+0xa2f>
mov    -0x2d8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x2e8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x2e0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x2f0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x2f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x300(%rbp),%rdi
call   1030 <free@plt>
add    $0x320,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CreateUmtsInterleaver>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rdx,0x90(%rsp)
mov    %rsi,%r15
mov    %edi,%r12d
lea    -0x28(%r12),%eax
cmp    $0x78,%eax
jae    116e <CreateUmtsInterleaver+0x3e>
mov    $0x1,%al
mov    %eax,0x2c(%rsp)
mov    $0x5,%esi
movl   $0x0,0x1c(%rsp)
jmp    11d0 <CreateUmtsInterleaver+0xa0>
lea    -0xa0(%r12),%eax
ff
cmp    $0x29,%eax
jae    1190 <CreateUmtsInterleaver+0x60>
mov    $0x1,%al
mov    %eax,0x1c(%rsp)
mov    $0xa,%esi
movl   $0x0,0x2c(%rsp)
jmp    11d0 <CreateUmtsInterleaver+0xa0>
lea    -0x1e1(%r12),%eax
ff
movl   $0x0,0x2c(%rsp)
cmp    $0x32,%eax
setb   %al
mov    %eax,0x1c(%rsp)
mov    $0xa,%eax
mov    $0x14,%esi
cmovb  %eax,%esi
jae    11d0 <CreateUmtsInterleaver+0xa0>
mov    $0x2,%r13d
mov    $0x35,%eax
mov    %rax,0x38(%rsp)
mov    $0x35,%ebp
jmp    1248 <CreateUmtsInterleaver+0x118>
mov    $0x1,%ecx
lea    0xe24(%rip),%rax
nopl   0x0(%rax)
mov    -0x4(%rax,%rcx,4),%edx
add    $0x1,%edx
imul   %esi,%edx
cmp    %r12d,%edx
jge    120e <CreateUmtsInterleaver+0xde>
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
imul   %esi,%edx
cmp    %r12d,%edx
jge    1212 <CreateUmtsInterleaver+0xe2>
add    $0x2,%rcx
cmp    $0x35,%rcx
jne    11e0 <CreateUmtsInterleaver+0xb0>
mov    $0x34,%ecx
jmp    1212 <CreateUmtsInterleaver+0xe2>
add    $0xffffffffffffffff,%rcx
mov    %ecx,%ecx
shl    $0x2,%rcx
mov    (%rcx,%rax,1),%edx
lea    0xeae(%rip),%rax
mov    (%rcx,%rax,1),%r13d
lea    -0x1(%rdx),%ebp
mov    %ebp,%eax
imul   %esi,%eax
cmp    %r12d,%eax
mov    %rdx,0x38(%rsp)
jge    1248 <CreateUmtsInterleaver+0x118>
mov    %edx,%eax
imul   %esi,%eax
xor    %ebp,%ebp
cmp    %r12d,%eax
setl   %bpl
add    %edx,%ebp
mov    %rsi,0x20(%rsp)
mov    %ebp,%ebx
imul   %esi,%ebx
mov    %ebx,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    %ebx,0x6c(%rsp)
mov    %ebx,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,0x30(%rsp)
movslq %r12d,%rax
mov    %ebp,%ecx
lea    -0x1(%rcx),%rdx
mov    %rdx,0x78(%rsp)
mov    %ecx,%r11d
and    $0xfffffffe,%r11d
mov    0x20(%rsp),%rdx
lea    (%rdx,%rdx,1),%r9d
mov    %r11,%r10
neg    %r10
xor    %esi,%esi
xor    %r8d,%r8d
mov    %rcx,0x8(%rsp)
jmp    12e0 <CreateUmtsInterleaver+0x1b0>
nopw   0x0(%rax,%rax,1)
imul   %edx,%ebp
add    %r8d,%ebp
mov    %edi,(%r14,%rbp,4)
add    $0x1,%rsi
mov    0x8(%rsp),%rcx
add    $0x1,%r8d
cmp    %edx,%r8d
je     1394 <CreateUmtsInterleaver+0x264>
test   %ecx,%ecx
jle    12d3 <CreateUmtsInterleaver+0x1a3>
movslq %esi,%rsi
cmpq   $0x0,0x78(%rsp)
je     1370 <CreateUmtsInterleaver+0x240>
xor    %ebp,%ebp
mov    %r8d,%ebx
jmp    131b <CreateUmtsInterleaver+0x1eb>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
add    %ebx,%ecx
mov    %edi,(%r14,%rcx,4)
add    $0x2,%rsi
add    %r9d,%ebx
add    $0xfffffffffffffffe,%rbp
cmp    %rbp,%r10
je     1350 <CreateUmtsInterleaver+0x220>
mov    $0xffffffff,%edi
mov    $0xffffffff,%ecx
cmp    %rax,%rsi
jge    132e <CreateUmtsInterleaver+0x1fe>
mov    (%r15,%rsi,4),%ecx
mov    %ebx,%edx
mov    %ecx,(%r14,%rdx,4)
lea    0x1(%rsi),%rcx
cmp    %rax,%rcx
jge    1300 <CreateUmtsInterleaver+0x1d0>
mov    0x4(%r15,%rsi,4),%edi
jmp    1300 <CreateUmtsInterleaver+0x1d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
neg    %rbp
mov    0x20(%rsp),%rdx
testb  $0x1,0x8(%rsp)
je     12ce <CreateUmtsInterleaver+0x19e>
jmp    137d <CreateUmtsInterleaver+0x24d>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebp,%ebp
testb  $0x1,0x8(%rsp)
je     12ce <CreateUmtsInterleaver+0x19e>
mov    $0xffffffff,%edi
cmp    %rax,%rsi
jge    12c0 <CreateUmtsInterleaver+0x190>
mov    (%r15,%rsi,4),%edi
jmp    12c0 <CreateUmtsInterleaver+0x190>
mov    %r11,0x88(%rsp)
mov    %r12,0x60(%rsp)
mov    0x38(%rsp),%rbx
lea    -0x1(%rbx),%r12d
mov    %r12d,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,0x40(%rsp)
movl   $0x1,(%rax)
mov    %r12d,%eax
mov    %rax,0x48(%rsp)
cmp    $0x3,%ebx
jl     1455 <CreateUmtsInterleaver+0x325>
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%rsi
cmp    $0x2,%r12d
jne    13ee <CreateUmtsInterleaver+0x2be>
mov    $0x1,%ecx
mov    $0x1,%edx
jmp    143c <CreateUmtsInterleaver+0x30c>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
mov    $0x1,%ecx
mov    $0x1,%edx
mov    0x40(%rsp),%rbp
mov    0x38(%rsp),%rbx
nopl   0x0(%rax)
imul   %r13d,%edx
mov    %edx,%eax
cltd
idiv   %ebx
mov    %edx,%eax
mov    %edx,0x0(%rbp,%rcx,4)
imul   %r13d,%eax
cltd
idiv   %ebx
mov    %edx,0x4(%rbp,%rcx,4)
lea    (%rdi,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
jne    1410 <CreateUmtsInterleaver+0x2e0>
test   $0x1,%sil
je     1455 <CreateUmtsInterleaver+0x325>
imul   %r13d,%edx
mov    %edx,%eax
cltd
idivl  0x38(%rsp)
mov    0x40(%rsp),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rsp),%r15
mov    %r15d,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,(%rsp)
movl   $0x1,(%rax)
mov    %r15d,%eax
xor    %r13d,%r13d
mov    $0x1,%ebp
mov    %rax,0x10(%rsp)
jmp    14a9 <CreateUmtsInterleaver+0x379>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x34,%r13d
mov    0x10(%rsp),%rax
mov    0x20(%rsp),%r15
add    $0x1,%rbp
cmp    %rax,%rbp
je     14f6 <CreateUmtsInterleaver+0x3c6>
cmp    $0x33,%r13d
jg     14a0 <CreateUmtsInterleaver+0x370>
movslq %r13d,%rax
lea    0xb47(%rip),%rcx
lea    (%rcx,%rax,4),%rbx
jmp    14ce <CreateUmtsInterleaver+0x39e>
nop
add    $0x1,%r13d
add    $0x4,%rbx
cmp    $0x34,%r13d
je     1490 <CreateUmtsInterleaver+0x360>
mov    (%rbx),%r15d
mov    %r15d,%edi
mov    %r12d,%esi
call   1050 <gcd@plt>
cmp    $0x1,%eax
jne    14c0 <CreateUmtsInterleaver+0x390>
mov    (%rsp),%rax
cmp    -0x4(%rax,%rbp,4),%r15d
jle    14c0 <CreateUmtsInterleaver+0x390>
mov    (%rsp),%rax
mov    %r15d,(%rax,%rbp,4)
jmp    1496 <CreateUmtsInterleaver+0x366>
mov    %r15d,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%rbx
cmpb   $0x0,0x2c(%rsp)
mov    %rax,0x50(%rsp)
je     153a <CreateUmtsInterleaver+0x40a>
mov    $0x4,%r9d
mov    $0x3,%ecx
mov    $0x2,%edx
mov    $0x1,%eax
mov    (%rsp),%rdi
mov    %rdi,%rsi
mov    0x8(%rsp),%rbp
mov    0x40(%rsp),%r13
jmp    1585 <CreateUmtsInterleaver+0x455>
cmpb   $0x0,0x1c(%rsp)
mov    0x8(%rsp),%rbp
mov    0x40(%rsp),%r13
je     15b1 <CreateUmtsInterleaver+0x481>
mov    (%rsp),%rdi
mov    (%rdi),%eax
mov    %eax,0x24(%rbx)
movdqu 0x4(%rdi),%xmm0
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,0x14(%rbx)
mov    %rdi,%rsi
add    $0x14,%rsi
mov    $0x1,%al
mov    %eax,0x1c(%rsp)
mov    $0x9,%r9d
mov    $0x8,%ecx
mov    $0x7,%edx
mov    $0x6,%eax
mov    0x10(%rsp),%r8
mov    (%rsi),%esi
mov    %esi,0x10(%rbx)
mov    (%rdi,%rax,4),%esi
mov    %esi,0xc(%rbx)
mov    (%rdi,%rdx,4),%edx
mov    %edx,0x8(%rbx)
mov    (%rdi,%rcx,4),%ecx
mov    %ecx,0x4(%rbx)
mov    (%rdi,%r9,4),%eax
mov    %eax,(%rbx)
mov    0x20(%rsp),%r15
jmp    1738 <CreateUmtsInterleaver+0x608>
mov    0x60(%rsp),%rcx
lea    -0x8e9(%rcx),%eax
cmp    $0xc8,%eax
jb     15eb <CreateUmtsInterleaver+0x4bb>
lea    -0xc59(%rcx),%eax
cmp    $0x32,%eax
jb     15eb <CreateUmtsInterleaver+0x4bb>
mov    0x10(%rsp),%r8
lea    -0x1(%r8),%rcx
mov    %r8d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
mov    (%rsp),%rdi
jae    160f <CreateUmtsInterleaver+0x4df>
xor    %ecx,%ecx
jmp    1667 <CreateUmtsInterleaver+0x537>
mov    0x10(%rsp),%r8
lea    -0x1(%r8),%rcx
mov    %r8d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
mov    (%rsp),%rdi
jae    16a8 <CreateUmtsInterleaver+0x578>
xor    %ecx,%ecx
jmp    1707 <CreateUmtsInterleaver+0x5d7>
mov    %r8d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
lea    0xbd2(%rip),%rsi
xchg   %ax,%ax
mov    (%rdi,%rcx,4),%edi
movslq (%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
mov    0x4(%rdi,%rcx,4),%edi
movslq 0x4(%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
mov    0x8(%rdi,%rcx,4),%edi
movslq 0x8(%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
mov    0xc(%rdi,%rcx,4),%edi
movslq 0xc(%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1620 <CreateUmtsInterleaver+0x4f0>
test   %rax,%rax
je     1733 <CreateUmtsInterleaver+0x603>
lea    0xb79(%rip),%rdx
lea    (%rdx,%rcx,4),%rdx
lea    (%rdi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,4),%edi
movslq (%rdx,%rsi,4),%rbp
mov    %edi,(%rbx,%rbp,4)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1690 <CreateUmtsInterleaver+0x560>
jmp    1733 <CreateUmtsInterleaver+0x603>
mov    %r8d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
lea    0xae9(%rip),%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,4),%edi
movslq (%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
mov    0x4(%rdi,%rcx,4),%edi
movslq 0x4(%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
mov    0x8(%rdi,%rcx,4),%edi
movslq 0x8(%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
mov    0xc(%rdi,%rcx,4),%edi
movslq 0xc(%rsi,%rcx,4),%rbp
mov    %edi,(%rbx,%rbp,4)
mov    (%rsp),%rdi
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    16c0 <CreateUmtsInterleaver+0x590>
test   %rax,%rax
je     1733 <CreateUmtsInterleaver+0x603>
lea    0xa8d(%rip),%rdx
lea    (%rdx,%rcx,4),%rdx
lea    (%rdi,%rcx,4),%rcx
xor    %esi,%esi
nopl   (%rax)
mov    (%rcx,%rsi,4),%edi
movslq (%rdx,%rsi,4),%rbp
mov    %edi,(%rbx,%rbp,4)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1720 <CreateUmtsInterleaver+0x5f0>
mov    0x8(%rsp),%rbp
mov    0x38(%rsp),%rsi
lea    0x1(%rsi),%r10d
mov    %r12d,%eax
imul   %r15d,%eax
mov    %esi,%ecx
imul   %r15d,%ecx
lea    -0x1(%r15),%edx
mov    %rdx,0x70(%rsp)
lea    (%rcx,%r15,1),%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
mov    %rdx,0x80(%rsp)
movslq %eax,%r15
movslq %ecx,%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%r8,4),%r11
xor    %edi,%edi
mov    0x30(%rsp),%r9
jmp    17c1 <CreateUmtsInterleaver+0x691>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rdi,4),%eax
lea    (%rdi,%r15,1),%rcx
mov    0x30(%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
mov    %r13,%rsi
add    $0x1,%rdi
add    $0x4,%r9
cmp    %r8,%rdi
mov    0x8(%rsp),%rbp
mov    %rsi,%r13
mov    0x38(%rsp),%rsi
je     1943 <CreateUmtsInterleaver+0x813>
cmp    %esi,%ebp
jne    1820 <CreateUmtsInterleaver+0x6f0>
cmp    $0x2,%esi
mov    0x10(%rsp),%r8
jl     1790 <CreateUmtsInterleaver+0x660>
mov    0x50(%rsp),%rax
mov    (%rax,%rdi,4),%ebx
xor    %ecx,%ecx
mov    0x48(%rsp),%rbp
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%eax
cltd
idiv   %r12d
movslq %edx,%rax
movslq 0x0(%r13,%rax,4),%rax
mov    %r8,%rdx
imul   %rax,%rdx
add    %rdi,%rdx
mov    (%r14,%rdx,4),%eax
mov    %eax,(%rsi)
add    %ebx,%ecx
add    %r11,%rsi
add    $0xffffffffffffffff,%rbp
jne    17f0 <CreateUmtsInterleaver+0x6c0>
jmp    1790 <CreateUmtsInterleaver+0x660>
xchg   %ax,%ax
cmp    %r10d,%ebp
jne    18e0 <CreateUmtsInterleaver+0x7b0>
cmp    $0x2,%esi
mov    0x10(%rsp),%r8
jl     1879 <CreateUmtsInterleaver+0x749>
mov    0x50(%rsp),%rax
mov    (%rax,%rdi,4),%ebx
xor    %ecx,%ecx
mov    0x48(%rsp),%rbp
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,%eax
cltd
idiv   %r12d
movslq %edx,%rax
movslq 0x0(%r13,%rax,4),%rax
mov    %r8,%rdx
imul   %rax,%rdx
add    %rdi,%rdx
mov    (%r14,%rdx,4),%eax
mov    %eax,(%rsi)
add    %ebx,%ecx
add    %r11,%rsi
add    $0xffffffffffffffff,%rbp
jne    1850 <CreateUmtsInterleaver+0x720>
lea    (%rdi,%r15,1),%rax
mov    0x20(%rsp),%rcx
add    %rdi,%rcx
mov    (%r14,%rdi,4),%edx
mov    0x30(%rsp),%rsi
mov    %edx,(%rsi,%rax,4)
mov    (%r14,%rcx,4),%eax
mov    %eax,(%rsi,%rcx,4)
mov    0x6c(%rsp),%eax
cmp    0x60(%rsp),%eax
mov    %r13,%rsi
jne    17a3 <CreateUmtsInterleaver+0x673>
cmp    0x70(%rsp),%rdi
jne    17a3 <CreateUmtsInterleaver+0x673>
mov    0x30(%rsp),%rdx
mov    0x70(%rsp),%rbx
mov    (%rdx,%rbx,4),%eax
mov    0x80(%rsp),%rbp
mov    (%rdx,%rbp,4),%ecx
mov    %ecx,(%rdx,%rbx,4)
mov    %eax,(%rdx,%rbp,4)
jmp    17a3 <CreateUmtsInterleaver+0x673>
nopw   0x0(%rax,%rax,1)
cmp    $0x2,%esi
mov    %r13,%rsi
mov    0x10(%rsp),%r8
jl     17a3 <CreateUmtsInterleaver+0x673>
mov    0x50(%rsp),%rax
mov    (%rax,%rdi,4),%ebx
xor    %ecx,%ecx
mov    0x48(%rsp),%rbp
mov    %r9,%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%eax
cltd
idiv   %r12d
movslq %edx,%rax
movslq (%rsi,%rax,4),%rax
add    $0xffffffffffffffff,%rax
mov    %r8,%rdx
imul   %rax,%rdx
add    %rdi,%rdx
mov    (%r14,%rdx,4),%eax
mov    %eax,0x0(%r13)
add    %ebx,%ecx
add    %r11,%r13
add    $0xffffffffffffffff,%rbp
jne    1910 <CreateUmtsInterleaver+0x7e0>
jmp    17a3 <CreateUmtsInterleaver+0x673>
mov    0x60(%rsp),%rcx
lea    -0x8e9(%rcx),%eax
cmp    $0xc8,%eax
setb   %al
add    $0xfffff3a7,%ecx
cmp    $0x32,%ecx
setb   %r12b
or     %al,%r12b
mov    0x10(%rsp),%r8
lea    0x0(,%r8,8),%rcx
xor    %r10d,%r10d
mov    0x88(%rsp),%r15
jmp    1992 <CreateUmtsInterleaver+0x862>
add    $0x1,%r10
cmp    %r8,%r10
mov    0x40(%rsp),%r13
je     1aa6 <CreateUmtsInterleaver+0x976>
cmpb   $0x0,0x2c(%rsp)
je     19b0 <CreateUmtsInterleaver+0x880>
lea    0x8a0(%rip),%rax
jmp    19e0 <CreateUmtsInterleaver+0x8b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x0,0x1c(%rsp)
je     19c0 <CreateUmtsInterleaver+0x890>
lea    0x8a2(%rip),%rax
jmp    19e0 <CreateUmtsInterleaver+0x8b0>
test   %r12b,%r12b
je     19ce <CreateUmtsInterleaver+0x89e>
lea    0x7d4(%rip),%rax
jmp    19e0 <CreateUmtsInterleaver+0x8b0>
lea    0x81b(%rip),%rax
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%r10,4),%rax
test   %ebp,%ebp
jle    1a50 <CreateUmtsInterleaver+0x920>
movslq (%rax),%r13
cmpq   $0x0,0x78(%rsp)
je     1a70 <CreateUmtsInterleaver+0x940>
lea    (%r8,%r10,1),%rax
mov    0x58(%rsp),%rdx
lea    (%rdx,%rax,4),%rsi
lea    (%r8,%r13,1),%rax
mov    0x30(%rsp),%rbp
lea    0x0(,%rax,4),%rdi
add    %rbp,%rdi
lea    (%rdx,%r10,4),%rax
lea    0x0(%rbp,%r13,4),%rbp
xor    %r8d,%r8d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp,%r8,1),%r9d
mov    %r9d,(%rax,%r8,1)
mov    (%rdi,%r8,1),%edx
mov    %edx,(%rsi,%r8,1)
add    $0x2,%rbx
add    %rcx,%r8
cmp    %rbx,%r15
jne    1a30 <CreateUmtsInterleaver+0x900>
jmp    1a72 <CreateUmtsInterleaver+0x942>
nop
add    $0x1,%r10
cmp    %r8,%r10
jne    1992 <CreateUmtsInterleaver+0x862>
jmp    1b38 <CreateUmtsInterleaver+0xa08>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
mov    0x8(%rsp),%rbp
test   $0x1,%bpl
mov    0x10(%rsp),%r8
je     1980 <CreateUmtsInterleaver+0x850>
imul   %r8,%rbx
add    %rbx,%r13
mov    0x30(%rsp),%rax
mov    (%rax,%r13,4),%eax
add    %r10,%rbx
mov    0x58(%rsp),%rdx
mov    %eax,(%rdx,%rbx,4)
jmp    1980 <CreateUmtsInterleaver+0x850>
test   %ebp,%ebp
jle    1b38 <CreateUmtsInterleaver+0xa08>
mov    %r8d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
mov    0x58(%rsp),%rdx
xor    %edi,%edi
mov    0x90(%rsp),%rbx
jmp    1ae1 <CreateUmtsInterleaver+0x9b1>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rsi
add    $0x1,%rcx
add    %r11,%rdx
cmp    %rsi,%rcx
je     1b38 <CreateUmtsInterleaver+0xa08>
xor    %ebp,%ebp
jmp    1af9 <CreateUmtsInterleaver+0x9c9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rbp
cmp    %rbp,%rax
je     1b20 <CreateUmtsInterleaver+0x9f0>
mov    (%rdx,%rbp,4),%esi
test   %esi,%esi
js     1b09 <CreateUmtsInterleaver+0x9d9>
movslq %edi,%rdi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%edi
mov    0x4(%rdx,%rbp,4),%esi
test   %esi,%esi
js     1af0 <CreateUmtsInterleaver+0x9c0>
movslq %edi,%rdi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%edi
jmp    1af0 <CreateUmtsInterleaver+0x9c0>
nopl   0x0(%rax)
test   $0x1,%r8b
je     1ad0 <CreateUmtsInterleaver+0x9a0>
mov    (%rdx,%rbp,4),%esi
test   %esi,%esi
js     1ad0 <CreateUmtsInterleaver+0x9a0>
movslq %edi,%rdi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%edi
jmp    1ad0 <CreateUmtsInterleaver+0x9a0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
@__const.CreateUmtsInterleaver.pTable = [52 x i32] [i32 7, i32 11, i32 13, i32 17, i32 19, i32 23, i32 29, i32 31, i32 37, i32 41, i32 43, i32 47, i32 53, i32 59, i32 61, i32 67, i32 71, i32 73, i32 79, i32 83, i32 89, i32 97, i32 101, i32 103, i32 107, i32 109, i32 113, i32 127, i32 131, i32 137, i32 139, i32 149, i32 151, i32 157, i32 163, i32 167, i32 173, i32 179, i32 181, i32 191, i32 193, i32 197, i32 199, i32 211, i32 223, i32 227, i32 229, i32 233, i32 239, i32 241, i32 251, i32 257]
@__const.CreateUmtsInterleaver.vTable = [52 x i32] [i32 3, i32 2, i32 2, i32 3, i32 2, i32 5, i32 2, i32 3, i32 2, i32 6, i32 3, i32 5, i32 2, i32 2, i32 2, i32 2, i32 7, i32 5, i32 3, i32 2, i32 3, i32 5, i32 2, i32 5, i32 2, i32 6, i32 3, i32 3, i32 2, i32 3, i32 2, i32 2, i32 6, i32 5, i32 2, i32 5, i32 2, i32 2, i32 2, i32 19, i32 5, i32 2, i32 3, i32 2, i32 3, i32 2, i32 6, i32 3, i32 7, i32 7, i32 6, i32 3]
@__const.CreateUmtsInterleaver.T5 = [5 x i32] [i32 4, i32 3, i32 2, i32 1, i32 0]
@__const.CreateUmtsInterleaver.T10 = [10 x i32] [i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0]
@__const.CreateUmtsInterleaver.T20a = [20 x i32] [i32 19, i32 9, i32 14, i32 4, i32 0, i32 2, i32 5, i32 7, i32 12, i32 18, i32 16, i32 13, i32 17, i32 15, i32 3, i32 1, i32 6, i32 11, i32 8, i32 10]
@__const.CreateUmtsInterleaver.T20b = [20 x i32] [i32 19, i32 9, i32 14, i32 4, i32 0, i32 2, i32 5, i32 7, i32 12, i32 18, i32 10, i32 8, i32 13, i32 17, i32 3, i32 1, i32 16, i32 6, i32 15, i32 11]
define void @CreateUmtsInterleaver(i32 %0, i32* %1, i32* %2) {
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca [52 x i32]
%16 = alloca [52 x i32]
%17 = alloca [5 x i32]
%18 = alloca [10 x i32]
%19 = alloca [20 x i32]
%20 = alloca [20 x i32]
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
store i32 %0, i32* %4
store i32* %1, i32** %5
store i32* %2, i32** %6
%27 = bitcast [52 x i32]* %15 to i8*
%28 = bitcast [52 x i32]* %16 to i8*
%29 = bitcast [5 x i32]* %17 to i8*
%30 = bitcast [10 x i32]* %18 to i8*
%31 = bitcast [20 x i32]* %19 to i8*
%32 = bitcast [20 x i32]* %20 to i8*
%33 = load i32, i32* %4
%34 = icmp sle i32 40, %33
br i1 %34, label %35, label %39
35: ; preds = %3
%36 = load i32, i32* %4
%37 = icmp sle i32 %36, 159
br i1 %37, label %38, label %39
38: ; preds = %35
store i32 5, i32* %7
br label %56
39: ; preds = %35, %3
%40 = load i32, i32* %4
%41 = icmp sle i32 160, %40
br i1 %41, label %42, label %46
42: ; preds = %39
%43 = load i32, i32* %4
%44 = icmp sle i32 %43, 200
br i1 %44, label %45, label %46
45: ; preds = %42
store i32 10, i32* %7
br label %55
46: ; preds = %42, %39
%47 = load i32, i32* %4
%48 = icmp sle i32 481, %47
br i1 %48, label %49, label %53
49: ; preds = %46
%50 = load i32, i32* %4
%51 = icmp sle i32 %50, 530
br i1 %51, label %52, label %53
52: ; preds = %49
store i32 10, i32* %7
br label %54
53: ; preds = %49, %46
store i32 20, i32* %7
br label %54
54: ; preds = %53, %52
br label %55
55: ; preds = %54, %45
br label %56
56: ; preds = %55, %38
%57 = load i32, i32* %4
%58 = icmp sle i32 481, %57
br i1 %58, label %59, label %64
59: ; preds = %56
%60 = load i32, i32* %4
%61 = icmp sle i32 %60, 530
br i1 %61, label %62, label %64
62: ; preds = %59
store i32 53, i32* %13
%63 = load i32, i32* %13
store i32 %63, i32* %8
store i32 2, i32* %14
br label %114
64: ; preds = %59, %56
store i32 0, i32* %9
br label %65
65: ; preds = %80, %64
%66 = load i32, i32* %9
%67 = icmp slt i32 %66, 52
br i1 %67, label %68, label %83
68: ; preds = %65
%69 = load i32, i32* %4
%70 = load i32, i32* %7
%71 = load i32, i32* %9
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [52 x i32], [52 x i32]* %15, i64 0, i64 %72
%74 = load i32, i32* %73
%75 = add nsw i32 %74, 1
%76 = mul nsw i32 %70, %75
%77 = icmp sle i32 %69, %76
br i1 %77, label %78, label %79
78: ; preds = %68
br label %83
79: ; preds = %68
br label %80
80: ; preds = %79
%81 = load i32, i32* %9
%82 = add nsw i32 %81, 1
store i32 %82, i32* %9
br label %65
83: ; preds = %78, %65
%84 = load i32, i32* %9
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [52 x i32], [52 x i32]* %15, i64 0, i64 %85
%87 = load i32, i32* %86
store i32 %87, i32* %13
%88 = load i32, i32* %9
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [52 x i32], [52 x i32]* %16, i64 0, i64 %89
%91 = load i32, i32* %90
store i32 %91, i32* %14
%92 = load i32, i32* %4
%93 = load i32, i32* %7
%94 = load i32, i32* %13
%95 = sub nsw i32 %94, 1
%96 = mul nsw i32 %93, %95
%97 = icmp sle i32 %92, %96
br i1 %97, label %98, label %101
98: ; preds = %83
%99 = load i32, i32* %13
%100 = sub nsw i32 %99, 1
store i32 %100, i32* %8
br label %113
101: ; preds = %83
%102 = load i32, i32* %7
%103 = load i32, i32* %13
%104 = mul nsw i32 %102, %103
%105 = load i32, i32* %4
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %110
107: ; preds = %101
%108 = load i32, i32* %13
%109 = add nsw i32 %108, 1
store i32 %109, i32* %8
br label %112
110: ; preds = %101
%111 = load i32, i32* %13
store i32 %111, i32* %8
br label %112
112: ; preds = %110, %107
br label %113
113: ; preds = %112, %98
br label %114
114: ; preds = %113, %62
%115 = load i32, i32* %7
%116 = load i32, i32* %8
%117 = mul nsw i32 %115, %116
%118 = call i32* @calloc(i32 %117, i32 4)
store i32* %118, i32** %21
%119 = load i32, i32* %7
%120 = load i32, i32* %8
%121 = mul nsw i32 %119, %120
%122 = call i32* @calloc(i32 %121, i32 4)
store i32* %122, i32** %23
%123 = load i32, i32* %7
%124 = load i32, i32* %8
%125 = mul nsw i32 %123, %124
%126 = call i32* @calloc(i32 %125, i32 4)
store i32* %126, i32** %22
store i32 0, i32* %9
store i32 0, i32* %10
br label %127
127: ; preds = %170, %114
%128 = load i32, i32* %10
%129 = load i32, i32* %7
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %173
131: ; preds = %127
store i32 0, i32* %11
br label %132
132: ; preds = %166, %131
%133 = load i32, i32* %11
%134 = load i32, i32* %8
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %169
136: ; preds = %132
%137 = load i32, i32* %9
%138 = load i32, i32* %4
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %154
140: ; preds = %136
%141 = load i32*, i32** %5
%142 = load i32, i32* %9
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %141, i64 %143
%145 = load i32, i32* %144
%146 = load i32*, i32** %21
%147 = load i32, i32* %10
%148 = load i32, i32* %11
%149 = load i32, i32* %7
%150 = mul nsw i32 %148, %149
%151 = add nsw i32 %147, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32, i32* %146, i64 %152
store i32 %145, i32* %153
br label %163
154: ; preds = %136
%155 = load i32*, i32** %21
%156 = load i32, i32* %10
%157 = load i32, i32* %11
%158 = load i32, i32* %7
%159 = mul nsw i32 %157, %158
%160 = add nsw i32 %156, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %155, i64 %161
store i32 -1, i32* %162
br label %163
163: ; preds = %154, %140
%164 = load i32, i32* %9
%165 = add nsw i32 %164, 1
store i32 %165, i32* %9
br label %166
166: ; preds = %163
%167 = load i32, i32* %11
%168 = add nsw i32 %167, 1
store i32 %168, i32* %11
br label %132
169: ; preds = %132
br label %170
170: ; preds = %169
%171 = load i32, i32* %10
%172 = add nsw i32 %171, 1
store i32 %172, i32* %10
br label %127
173: ; preds = %127
%174 = load i32, i32* %13
%175 = sub nsw i32 %174, 1
%176 = call i32* @calloc(i32 %175, i32 4)
store i32* %176, i32** %24
%177 = load i32*, i32** %24
%178 = getelementptr inbounds i32, i32* %177, i64 0
store i32 1, i32* %178
store i32 1, i32* %11
br label %179
179: ; preds = %199, %173
%180 = load i32, i32* %11
%181 = load i32, i32* %13
%182 = sub nsw i32 %181, 1
%183 = icmp slt i32 %180, %182
br i1 %183, label %184, label %202
184: ; preds = %179
%185 = load i32, i32* %14
%186 = load i32*, i32** %24
%187 = load i32, i32* %11
%188 = sub nsw i32 %187, 1
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32, i32* %186, i64 %189
%191 = load i32, i32* %190
%192 = mul nsw i32 %185, %191
%193 = load i32, i32* %13
%194 = srem i32 %192, %193
%195 = load i32*, i32** %24
%196 = load i32, i32* %11
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
store i32 %194, i32* %198
br label %199
199: ; preds = %184
%200 = load i32, i32* %11
%201 = add nsw i32 %200, 1
store i32 %201, i32* %11
br label %179
202: ; preds = %179
%203 = load i32, i32* %7
%204 = call i32* @calloc(i32 %203, i32 4)
store i32* %204, i32** %25
%205 = load i32*, i32** %25
%206 = getelementptr inbounds i32, i32* %205, i64 0
store i32 1, i32* %206
store i32 0, i32* %9
store i32 1, i32* %10
br label %207
207: ; preds = %252, %202
%208 = load i32, i32* %10
%209 = load i32, i32* %7
%210 = icmp slt i32 %208, %209
br i1 %210, label %211, label %255
211: ; preds = %207
%212 = load i32, i32* %9
store i32 %212, i32* %12
%213 = load i32, i32* %12
store i32 %213, i32* %9
br label %214
214: ; preds = %248, %211
%215 = load i32, i32* %9
%216 = icmp slt i32 %215, 52
br i1 %216, label %217, label %251
217: ; preds = %214
%218 = load i32, i32* %9
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [52 x i32], [52 x i32]* %15, i64 0, i64 %219
%221 = load i32, i32* %220
%222 = load i32, i32* %13
%223 = sub nsw i32 %222, 1
%224 = call i32 @gcd(i32 %221, i32 %223)
%225 = icmp eq i32 %224, 1
br i1 %225, label %226, label %247
226: ; preds = %217
%227 = load i32, i32* %9
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [52 x i32], [52 x i32]* %15, i64 0, i64 %228
%230 = load i32, i32* %229
%231 = load i32*, i32** %25
%232 = load i32, i32* %10
%233 = sub nsw i32 %232, 1
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %231, i64 %234
%236 = load i32, i32* %235
%237 = icmp sgt i32 %230, %236
br i1 %237, label %238, label %247
238: ; preds = %226
%239 = load i32, i32* %9
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [52 x i32], [52 x i32]* %15, i64 0, i64 %240
%242 = load i32, i32* %241
%243 = load i32*, i32** %25
%244 = load i32, i32* %10
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i32, i32* %243, i64 %245
store i32 %242, i32* %246
br label %251
247: ; preds = %226, %217
br label %248
248: ; preds = %247
%249 = load i32, i32* %9
%250 = add nsw i32 %249, 1
store i32 %250, i32* %9
br label %214
251: ; preds = %238, %214
br label %252
252: ; preds = %251
%253 = load i32, i32* %10
%254 = add nsw i32 %253, 1
store i32 %254, i32* %10
br label %207
255: ; preds = %207
%256 = load i32, i32* %7
%257 = call i32* @calloc(i32 %256, i32 4)
store i32* %257, i32** %26
%258 = load i32, i32* %7
%259 = icmp eq i32 %258, 5
br i1 %259, label %260, label %282
260: ; preds = %255
store i32 0, i32* %10
br label %261
261: ; preds = %278, %260
%262 = load i32, i32* %10
%263 = load i32, i32* %7
%264 = icmp slt i32 %262, %263
br i1 %264, label %265, label %281
265: ; preds = %261
%266 = load i32*, i32** %25
%267 = load i32, i32* %10
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i32, i32* %266, i64 %268
%270 = load i32, i32* %269
%271 = load i32*, i32** %26
%272 = load i32, i32* %10
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds [5 x i32], [5 x i32]* %17, i64 0, i64 %273
%275 = load i32, i32* %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i32, i32* %271, i64 %276
store i32 %270, i32* %277
br label %278
278: ; preds = %265
%279 = load i32, i32* %10
%280 = add nsw i32 %279, 1
store i32 %280, i32* %10
br label %261
281: ; preds = %261
br label %365
282: ; preds = %255
%283 = load i32, i32* %7
%284 = icmp eq i32 %283, 10
br i1 %284, label %285, label %307
285: ; preds = %282
store i32 0, i32* %10
br label %286
286: ; preds = %303, %285
%287 = load i32, i32* %10
%288 = load i32, i32* %7
%289 = icmp slt i32 %287, %288
br i1 %289, label %290, label %306
290: ; preds = %286
%291 = load i32*, i32** %25
%292 = load i32, i32* %10
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %291, i64 %293
%295 = load i32, i32* %294
%296 = load i32*, i32** %26
%297 = load i32, i32* %10
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [10 x i32], [10 x i32]* %18, i64 0, i64 %298
%300 = load i32, i32* %299
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i32, i32* %296, i64 %301
store i32 %295, i32* %302
br label %303
303: ; preds = %290
%304 = load i32, i32* %10
%305 = add nsw i32 %304, 1
store i32 %305, i32* %10
br label %286
306: ; preds = %286
br label %364
307: ; preds = %282
%308 = load i32, i32* %4
%309 = icmp sle i32 2281, %308
br i1 %309, label %310, label %313
310: ; preds = %307
%311 = load i32, i32* %4
%312 = icmp sle i32 %311, 2480
br i1 %312, label %319, label %313
313: ; preds = %310, %307
%314 = load i32, i32* %4
%315 = icmp sle i32 3161, %314
br i1 %315, label %316, label %341
316: ; preds = %313
%317 = load i32, i32* %4
%318 = icmp sle i32 %317, 3210
br i1 %318, label %319, label %341
319: ; preds = %316, %310
store i32 0, i32* %10
br label %320
320: ; preds = %337, %319
%321 = load i32, i32* %10
%322 = load i32, i32* %7
%323 = icmp slt i32 %321, %322
br i1 %323, label %324, label %340
324: ; preds = %320
%325 = load i32*, i32** %25
%326 = load i32, i32* %10
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i32, i32* %325, i64 %327
%329 = load i32, i32* %328
%330 = load i32*, i32** %26
%331 = load i32, i32* %10
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [20 x i32], [20 x i32]* %19, i64 0, i64 %332
%334 = load i32, i32* %333
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i32, i32* %330, i64 %335
store i32 %329, i32* %336
br label %337
337: ; preds = %324
%338 = load i32, i32* %10
%339 = add nsw i32 %338, 1
store i32 %339, i32* %10
br label %320
340: ; preds = %320
br label %363
341: ; preds = %316, %313
store i32 0, i32* %10
br label %342
342: ; preds = %359, %341
%343 = load i32, i32* %10
%344 = load i32, i32* %7
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %362
346: ; preds = %342
%347 = load i32*, i32** %25
%348 = load i32, i32* %10
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i32, i32* %347, i64 %349
%351 = load i32, i32* %350
%352 = load i32*, i32** %26
%353 = load i32, i32* %10
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [20 x i32], [20 x i32]* %20, i64 0, i64 %354
%356 = load i32, i32* %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i32, i32* %352, i64 %357
store i32 %351, i32* %358
br label %359
359: ; preds = %346
%360 = load i32, i32* %10
%361 = add nsw i32 %360, 1
store i32 %361, i32* %10
br label %342
362: ; preds = %342
br label %363
363: ; preds = %362, %340
br label %364
364: ; preds = %363, %306
br label %365
365: ; preds = %364, %281
store i32 0, i32* %10
br label %366
366: ; preds = %596, %365
%367 = load i32, i32* %10
%368 = load i32, i32* %7
%369 = icmp slt i32 %367, %368
br i1 %369, label %370, label %599
370: ; preds = %366
%371 = load i32, i32* %8
%372 = load i32, i32* %13
%373 = icmp eq i32 %371, %372
br i1 %373, label %374, label %430
374: ; preds = %370
store i32 0, i32* %11
br label %375
375: ; preds = %412, %374
%376 = load i32, i32* %11
%377 = load i32, i32* %13
%378 = sub nsw i32 %377, 2
%379 = icmp sle i32 %376, %378
br i1 %379, label %380, label %415
380: ; preds = %375
%381 = load i32*, i32** %24
%382 = load i32, i32* %11
%383 = load i32*, i32** %26
%384 = load i32, i32* %10
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i32, i32* %383, i64 %385
%387 = load i32, i32* %386
%388 = mul nsw i32 %382, %387
%389 = load i32, i32* %13
%390 = sub nsw i32 %389, 1
%391 = srem i32 %388, %390
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds i32, i32* %381, i64 %392
%394 = load i32, i32* %393
store i32 %394, i32* %9
%395 = load i32*, i32** %21
%396 = load i32, i32* %10
%397 = load i32, i32* %9
%398 = load i32, i32* %7
%399 = mul nsw i32 %397, %398
%400 = add nsw i32 %396, %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds i32, i32* %395, i64 %401
%403 = load i32, i32* %402
%404 = load i32*, i32** %22
%405 = load i32, i32* %10
%406 = load i32, i32* %11
%407 = load i32, i32* %7
%408 = mul nsw i32 %406, %407
%409 = add nsw i32 %405, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds i32, i32* %404, i64 %410
store i32 %403, i32* %411
br label %412
412: ; preds = %380
%413 = load i32, i32* %11
%414 = add nsw i32 %413, 1
store i32 %414, i32* %11
br label %375
415: ; preds = %375
%416 = load i32*, i32** %21
%417 = load i32, i32* %10
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i32, i32* %416, i64 %418
%420 = load i32, i32* %419
%421 = load i32*, i32** %22
%422 = load i32, i32* %10
%423 = load i32, i32* %13
%424 = sub nsw i32 %423, 1
%425 = load i32, i32* %7
%426 = mul nsw i32 %424, %425
%427 = add nsw i32 %422, %426
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i32, i32* %421, i64 %428
store i32 %420, i32* %429
br label %595
430: ; preds = %370
%431 = load i32, i32* %8
%432 = load i32, i32* %13
%433 = add nsw i32 %432, 1
%434 = icmp eq i32 %431, %433
br i1 %434, label %435, label %551
435: ; preds = %430
store i32 0, i32* %11
br label %436
436: ; preds = %473, %435
%437 = load i32, i32* %11
%438 = load i32, i32* %13
%439 = sub nsw i32 %438, 2
%440 = icmp sle i32 %437, %439
br i1 %440, label %441, label %476
441: ; preds = %436
%442 = load i32*, i32** %24
%443 = load i32, i32* %11
%444 = load i32*, i32** %26
%445 = load i32, i32* %10
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i32, i32* %444, i64 %446
%448 = load i32, i32* %447
%449 = mul nsw i32 %443, %448
%450 = load i32, i32* %13
%451 = sub nsw i32 %450, 1
%452 = srem i32 %449, %451
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds i32, i32* %442, i64 %453
%455 = load i32, i32* %454
store i32 %455, i32* %9
%456 = load i32*, i32** %21
%457 = load i32, i32* %10
%458 = load i32, i32* %9
%459 = load i32, i32* %7
%460 = mul nsw i32 %458, %459
%461 = add nsw i32 %457, %460
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds i32, i32* %456, i64 %462
%464 = load i32, i32* %463
%465 = load i32*, i32** %22
%466 = load i32, i32* %10
%467 = load i32, i32* %11
%468 = load i32, i32* %7
%469 = mul nsw i32 %467, %468
%470 = add nsw i32 %466, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32, i32* %465, i64 %471
store i32 %464, i32* %472
br label %473
473: ; preds = %441
%474 = load i32, i32* %11
%475 = add nsw i32 %474, 1
store i32 %475, i32* %11
br label %436
476: ; preds = %436
%477 = load i32*, i32** %21
%478 = load i32, i32* %10
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds i32, i32* %477, i64 %479
%481 = load i32, i32* %480
%482 = load i32*, i32** %22
%483 = load i32, i32* %10
%484 = load i32, i32* %13
%485 = sub nsw i32 %484, 1
%486 = load i32, i32* %7
%487 = mul nsw i32 %485, %486
%488 = add nsw i32 %483, %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i32, i32* %482, i64 %489
store i32 %481, i32* %490
%491 = load i32*, i32** %21
%492 = load i32, i32* %10
%493 = load i32, i32* %13
%494 = load i32, i32* %7
%495 = mul nsw i32 %493, %494
%496 = add nsw i32 %492, %495
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds i32, i32* %491, i64 %497
%499 = load i32, i32* %498
%500 = load i32*, i32** %22
%501 = load i32, i32* %10
%502 = load i32, i32* %13
%503 = load i32, i32* %7
%504 = mul nsw i32 %502, %503
%505 = add nsw i32 %501, %504
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i32, i32* %500, i64 %506
store i32 %499, i32* %507
%508 = load i32, i32* %4
%509 = load i32, i32* %7
%510 = load i32, i32* %8
%511 = mul nsw i32 %509, %510
%512 = icmp eq i32 %508, %511
br i1 %512, label %513, label %550
513: ; preds = %476
%514 = load i32, i32* %10
%515 = load i32, i32* %7
%516 = sub nsw i32 %515, 1
%517 = icmp eq i32 %514, %516
br i1 %517, label %518, label %550
518: ; preds = %513
%519 = load i32*, i32** %22
%520 = load i32, i32* %7
%521 = sub nsw i32 %520, 1
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32, i32* %519, i64 %522
%524 = load i32, i32* %523
store i32 %524, i32* %12
%525 = load i32*, i32** %22
%526 = load i32, i32* %7
%527 = sub nsw i32 %526, 1
%528 = load i32, i32* %7
%529 = load i32, i32* %13
%530 = mul nsw i32 %528, %529
%531 = add nsw i32 %527, %530
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds i32, i32* %525, i64 %532
%534 = load i32, i32* %533
%535 = load i32*, i32** %22
%536 = load i32, i32* %7
%537 = sub nsw i32 %536, 1
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i32, i32* %535, i64 %538
store i32 %534, i32* %539
%540 = load i32, i32* %12
%541 = load i32*, i32** %22
%542 = load i32, i32* %7
%543 = sub nsw i32 %542, 1
%544 = load i32, i32* %7
%545 = load i32, i32* %13
%546 = mul nsw i32 %544, %545
%547 = add nsw i32 %543, %546
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds i32, i32* %541, i64 %548
store i32 %540, i32* %549
br label %550
550: ; preds = %518, %513, %476
br label %594
551: ; preds = %430
store i32 0, i32* %11
br label %552
552: ; preds = %590, %551
%553 = load i32, i32* %11
%554 = load i32, i32* %13
%555 = sub nsw i32 %554, 2
%556 = icmp sle i32 %553, %555
br i1 %556, label %557, label %593
557: ; preds = %552
%558 = load i32*, i32** %24
%559 = load i32, i32* %11
%560 = load i32*, i32** %26
%561 = load i32, i32* %10
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds i32, i32* %560, i64 %562
%564 = load i32, i32* %563
%565 = mul nsw i32 %559, %564
%566 = load i32, i32* %13
%567 = sub nsw i32 %566, 1
%568 = srem i32 %565, %567
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds i32, i32* %558, i64 %569
%571 = load i32, i32* %570
%572 = sub nsw i32 %571, 1
store i32 %572, i32* %9
%573 = load i32*, i32** %21
%574 = load i32, i32* %10
%575 = load i32, i32* %9
%576 = load i32, i32* %7
%577 = mul nsw i32 %575, %576
%578 = add nsw i32 %574, %577
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds i32, i32* %573, i64 %579
%581 = load i32, i32* %580
%582 = load i32*, i32** %22
%583 = load i32, i32* %10
%584 = load i32, i32* %11
%585 = load i32, i32* %7
%586 = mul nsw i32 %584, %585
%587 = add nsw i32 %583, %586
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds i32, i32* %582, i64 %588
store i32 %581, i32* %589
br label %590
590: ; preds = %557
%591 = load i32, i32* %11
%592 = add nsw i32 %591, 1
store i32 %592, i32* %11
br label %552
593: ; preds = %552
br label %594
594: ; preds = %593, %550
br label %595
595: ; preds = %594, %415
br label %596
596: ; preds = %595
%597 = load i32, i32* %10
%598 = add nsw i32 %597, 1
store i32 %598, i32* %10
br label %366
599: ; preds = %366
store i32 0, i32* %10
br label %600
600: ; preds = %671, %599
%601 = load i32, i32* %10
%602 = load i32, i32* %7
%603 = icmp slt i32 %601, %602
br i1 %603, label %604, label %674
604: ; preds = %600
%605 = load i32, i32* %7
%606 = icmp eq i32 %605, 5
br i1 %606, label %607, label %612
607: ; preds = %604
%608 = load i32, i32* %10
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds [5 x i32], [5 x i32]* %17, i64 0, i64 %609
%611 = load i32, i32* %610
store i32 %611, i32* %9
br label %644
612: ; preds = %604
%613 = load i32, i32* %7
%614 = icmp eq i32 %613, 10
br i1 %614, label %615, label %620
615: ; preds = %612
%616 = load i32, i32* %10
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds [10 x i32], [10 x i32]* %18, i64 0, i64 %617
%619 = load i32, i32* %618
store i32 %619, i32* %9
br label %643
620: ; preds = %612
%621 = load i32, i32* %4
%622 = icmp sle i32 2281, %621
br i1 %622, label %623, label %626
623: ; preds = %620
%624 = load i32, i32* %4
%625 = icmp sle i32 %624, 2480
br i1 %625, label %632, label %626
626: ; preds = %623, %620
%627 = load i32, i32* %4
%628 = icmp sle i32 3161, %627
br i1 %628, label %629, label %637
629: ; preds = %626
%630 = load i32, i32* %4
%631 = icmp sle i32 %630, 3210
br i1 %631, label %632, label %637
632: ; preds = %629, %623
%633 = load i32, i32* %10
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds [20 x i32], [20 x i32]* %19, i64 0, i64 %634
%636 = load i32, i32* %635
store i32 %636, i32* %9
br label %642
637: ; preds = %629, %626
%638 = load i32, i32* %10
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds [20 x i32], [20 x i32]* %20, i64 0, i64 %639
%641 = load i32, i32* %640
store i32 %641, i32* %9
br label %642
642: ; preds = %637, %632
br label %643
643: ; preds = %642, %615
br label %644
644: ; preds = %643, %607
store i32 0, i32* %11
br label %645
645: ; preds = %667, %644
%646 = load i32, i32* %11
%647 = load i32, i32* %8
%648 = icmp slt i32 %646, %647
br i1 %648, label %649, label %670
649: ; preds = %645
%650 = load i32*, i32** %22
%651 = load i32, i32* %9
%652 = load i32, i32* %11
%653 = load i32, i32* %7
%654 = mul nsw i32 %652, %653
%655 = add nsw i32 %651, %654
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds i32, i32* %650, i64 %656
%658 = load i32, i32* %657
%659 = load i32*, i32** %23
%660 = load i32, i32* %10
%661 = load i32, i32* %11
%662 = load i32, i32* %7
%663 = mul nsw i32 %661, %662
%664 = add nsw i32 %660, %663
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds i32, i32* %659, i64 %665
store i32 %658, i32* %666
br label %667
667: ; preds = %649
%668 = load i32, i32* %11
%669 = add nsw i32 %668, 1
store i32 %669, i32* %11
br label %645
670: ; preds = %645
br label %671
671: ; preds = %670
%672 = load i32, i32* %10
%673 = add nsw i32 %672, 1
store i32 %673, i32* %10
br label %600
674: ; preds = %600
store i32 0, i32* %9
store i32 0, i32* %11
br label %675
675: ; preds = %716, %674
%676 = load i32, i32* %11
%677 = load i32, i32* %8
%678 = icmp slt i32 %676, %677
br i1 %678, label %679, label %719
679: ; preds = %675
store i32 0, i32* %10
br label %680
680: ; preds = %712, %679
%681 = load i32, i32* %10
%682 = load i32, i32* %7
%683 = icmp slt i32 %681, %682
br i1 %683, label %684, label %715
684: ; preds = %680
%685 = load i32*, i32** %23
%686 = load i32, i32* %10
%687 = load i32, i32* %11
%688 = load i32, i32* %7
%689 = mul nsw i32 %687, %688
%690 = add nsw i32 %686, %689
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds i32, i32* %685, i64 %691
%693 = load i32, i32* %692
%694 = icmp sge i32 %693, 0
br i1 %694, label %695, label %711
695: ; preds = %684
%696 = load i32*, i32** %23
%697 = load i32, i32* %10
%698 = load i32, i32* %11
%699 = load i32, i32* %7
%700 = mul nsw i32 %698, %699
%701 = add nsw i32 %697, %700
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds i32, i32* %696, i64 %702
%704 = load i32, i32* %703
%705 = load i32*, i32** %6
%706 = load i32, i32* %9
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds i32, i32* %705, i64 %707
store i32 %704, i32* %708
%709 = load i32, i32* %9
%710 = add nsw i32 %709, 1
store i32 %710, i32* %9
br label %711
711: ; preds = %695, %684
br label %712
712: ; preds = %711
%713 = load i32, i32* %10
%714 = add nsw i32 %713, 1
store i32 %714, i32* %10
br label %680
715: ; preds = %680
br label %716
716: ; preds = %715
%717 = load i32, i32* %11
%718 = add nsw i32 %717, 1
store i32 %718, i32* %11
br label %675
719: ; preds = %675
%720 = load i32*, i32** %21
%721 = call i32 @free(i32* %720)
%722 = load i32*, i32** %23
%723 = call i32 @free(i32* %722)
%724 = load i32*, i32** %22
%725 = call i32 @free(i32* %724)
%726 = load i32*, i32** %24
%727 = call i32 @free(i32* %726)
%728 = load i32*, i32** %25
%729 = call i32 @free(i32* %728)
%730 = load i32*, i32** %26
%731 = call i32 @free(i32* %730)
ret void
}

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