#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char const *);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ stderr;
scalar_t__ strlen(char const *);
int *vrna_alloc(int);
int *vrna_idx_col_wise(unsigned int);
int *vrna_idx_row_wise(unsigned int);
int /*<<< orphan*/ vrna_message_error(char *);
void constrain_ptypes(const char *constraint, unsigned int length, char *ptype,
                      int *BP, int min_loop_size, unsigned int idx_type) {
  int n, i, j, k, l;
  int hx, *stack;
  char type;
  int *index;
  if (constraint == NULL)
    return;
  n = (int)strlen(constraint);
  stack = vrna_alloc(sizeof(int) * (n + 1));
  if (!idx_type) {
    index = vrna_idx_col_wise(length);
    for (hx = 0, j = 1; j <= n; j++) {
      switch (constraint[j - 1]) {
      case '|':
        if (BP)
          BP[j] = -1;
        break;
      case 'x':
        for (l = 1; l < j - min_loop_size; l++)
          ptype[index[j] + l] = 0;
        for (l = j + min_loop_size + 1; l <= (int)length; l++)
          ptype[index[l] + j] = 0;
        break;
      case '(':
        stack[hx++] = j;
      case '<':
        for (l = 1; l < j - min_loop_size; l++)
          ptype[index[j] + l] = 0;
        break;
      case ')':
        if (hx <= 0) {
          fprintf(stderr, "%s\n", constraint);
          vrna_message_error("unbalanced brackets in constraint");
        }
        i = stack[--hx];
        type = ptype[index[j] + i];
        for (k = i + 1; k <= (int)length; k++)
          ptype[index[k] + i] = 0;
        for (l = j; l <= (int)length; l++)
          for (k = i + 1; k <= j; k++)
            ptype[index[l] + k] = 0;
        for (l = i; l <= j; l++)
          for (k = 1; k <= i; k++)
            ptype[index[l] + k] = 0;
        for (k = 1; k < j; k++)
          ptype[index[j] + k] = 0;
        ptype[index[j] + i] = (type == 0) ? 7 : type;
      case '>':
        for (l = j + min_loop_size + 1; l <= (int)length; l++)
          ptype[index[l] + j] = 0;
        break;
      }
    }
  } else {
    index = vrna_idx_row_wise(length);
    for (hx = 0, j = 1; j <= n; j++) {
      switch (constraint[j - 1]) {
      case 'x':
        for (l = 1; l < j - min_loop_size; l++)
          ptype[index[l] - j] = 0;
        for (l = j + min_loop_size + 1; l <= (int)length; l++)
          ptype[index[j] - l] = 0;
        break;
      case '(':
        stack[hx++] = j;
      case '<':
        for (l = 1; l < j - min_loop_size; l++)
          ptype[index[l] - j] = 0;
        break;
      case ')':
        if (hx <= 0) {
          fprintf(stderr, "%s\n", constraint);
          vrna_message_error("unbalanced brackets in constraints");
        }
        i = stack[--hx];
        type = ptype[index[i] - j];
        for (k = i; k <= j; k++)
          for (l = j; l <= (int)length; l++)
            ptype[index[k] - l] = 0;
        for (k = 1; k <= i; k++)
          for (l = i; l <= j; l++)
            ptype[index[k] - l] = 0;
        ptype[index[i] - j] = (type == 0) ? 7 : type;
      case '>':
        for (l = j + min_loop_size + 1; l <= (int)length; l++)
          ptype[index[j] - l] = 0;
        break;
      }
    }
  }
  if (hx != 0) {
    fprintf(stderr, "%s\n", constraint);
    vrna_message_error("unbalanced brackets in constraint string");
  }
  free(index);
  free(stack);
}


x86 assembly (clang, -O0):
<constrain_ptypes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
cmpq   $0x0,-0x8(%rbp)
jne    119f <constrain_ptypes+0x2f>
jmp    18fa <constrain_ptypes+0x78a>
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <vrna_alloc@plt>
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    1597 <constrain_ptypes+0x427>
mov    -0xc(%rbp),%edi
call   1090 <vrna_idx_col_wise@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1592 <constrain_ptypes+0x422>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
sub    $0x28,%eax
je     130b <constrain_ptypes+0x19b>
jmp    1214 <constrain_ptypes+0xa4>
mov    -0x5c(%rbp),%eax
sub    $0x29,%eax
je     1367 <constrain_ptypes+0x1f7>
jmp    1225 <constrain_ptypes+0xb5>
mov    -0x5c(%rbp),%eax
sub    $0x3c,%eax
je     1323 <constrain_ptypes+0x1b3>
jmp    1236 <constrain_ptypes+0xc6>
mov    -0x5c(%rbp),%eax
sub    $0x3e,%eax
je     153b <constrain_ptypes+0x3cb>
jmp    1247 <constrain_ptypes+0xd7>
mov    -0x5c(%rbp),%eax
sub    $0x78,%eax
je     1288 <constrain_ptypes+0x118>
jmp    1258 <constrain_ptypes+0xe8>
mov    -0x5c(%rbp),%eax
sub    $0x7c,%eax
jne    157f <constrain_ptypes+0x40f>
jmp    1269 <constrain_ptypes+0xf9>
cmpq   $0x0,-0x20(%rbp)
je     1283 <constrain_ptypes+0x113>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    157f <constrain_ptypes+0x40f>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    12c7 <constrain_ptypes+0x157>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    128f <constrain_ptypes+0x11f>
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1306 <constrain_ptypes+0x196>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12d3 <constrain_ptypes+0x163>
jmp    157f <constrain_ptypes+0x40f>
mov    -0x34(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    1362 <constrain_ptypes+0x1f2>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    132a <constrain_ptypes+0x1ba>
jmp    157f <constrain_ptypes+0x40f>
cmpl   $0x0,-0x40(%rbp)
jg     1396 <constrain_ptypes+0x226>
mov    0x2c68(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0xc7b(%rip),%rsi
call   1050 <fprintf@plt>
lea    0xc73(%rip),%rdi
call   1060 <vrna_message_error@plt>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x49(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1403 <constrain_ptypes+0x293>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13d0 <constrain_ptypes+0x260>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1464 <constrain_ptypes+0x2f4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1451 <constrain_ptypes+0x2e1>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    141e <constrain_ptypes+0x2ae>
jmp    1456 <constrain_ptypes+0x2e6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1409 <constrain_ptypes+0x299>
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     14c3 <constrain_ptypes+0x353>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     14b0 <constrain_ptypes+0x340>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    147d <constrain_ptypes+0x30d>
jmp    14b5 <constrain_ptypes+0x345>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    146a <constrain_ptypes+0x2fa>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    14fd <constrain_ptypes+0x38d>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14ca <constrain_ptypes+0x35a>
movsbl -0x49(%rbp),%eax
cmp    $0x0,%eax
jne    1517 <constrain_ptypes+0x3a7>
mov    $0x7,%eax
mov    %eax,-0x60(%rbp)
jmp    151e <constrain_ptypes+0x3ae>
movsbl -0x49(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     157a <constrain_ptypes+0x40a>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1547 <constrain_ptypes+0x3d7>
jmp    157f <constrain_ptypes+0x40f>
jmp    1584 <constrain_ptypes+0x414>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11e6 <constrain_ptypes+0x76>
jmp    18b9 <constrain_ptypes+0x749>
mov    -0xc(%rbp),%edi
call   1070 <vrna_idx_row_wise@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     18b4 <constrain_ptypes+0x744>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
sub    $0x28,%eax
je     16a6 <constrain_ptypes+0x536>
jmp    15df <constrain_ptypes+0x46f>
mov    -0x64(%rbp),%eax
sub    $0x29,%eax
je     1702 <constrain_ptypes+0x592>
jmp    15f0 <constrain_ptypes+0x480>
mov    -0x64(%rbp),%eax
sub    $0x3c,%eax
je     16be <constrain_ptypes+0x54e>
jmp    1601 <constrain_ptypes+0x491>
mov    -0x64(%rbp),%eax
sub    $0x3e,%eax
je     185d <constrain_ptypes+0x6ed>
jmp    1612 <constrain_ptypes+0x4a2>
mov    -0x64(%rbp),%eax
sub    $0x78,%eax
jne    18a1 <constrain_ptypes+0x731>
jmp    1623 <constrain_ptypes+0x4b3>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    1662 <constrain_ptypes+0x4f2>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    162a <constrain_ptypes+0x4ba>
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     16a1 <constrain_ptypes+0x531>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    166e <constrain_ptypes+0x4fe>
jmp    18a1 <constrain_ptypes+0x731>
mov    -0x34(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    16fd <constrain_ptypes+0x58d>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16c5 <constrain_ptypes+0x555>
jmp    18a1 <constrain_ptypes+0x731>
cmpl   $0x0,-0x40(%rbp)
jg     1731 <constrain_ptypes+0x5c1>
mov    0x28cd(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0x8e0(%rip),%rsi
call   1050 <fprintf@plt>
lea    0x8fa(%rip),%rdi
call   1060 <vrna_message_error@plt>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x49(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     17c0 <constrain_ptypes+0x650>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     17ad <constrain_ptypes+0x63d>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    177a <constrain_ptypes+0x60a>
jmp    17b2 <constrain_ptypes+0x642>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1768 <constrain_ptypes+0x5f8>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     181f <constrain_ptypes+0x6af>
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     180c <constrain_ptypes+0x69c>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17d9 <constrain_ptypes+0x669>
jmp    1811 <constrain_ptypes+0x6a1>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17c7 <constrain_ptypes+0x657>
movsbl -0x49(%rbp),%eax
cmp    $0x0,%eax
jne    1839 <constrain_ptypes+0x6c9>
mov    $0x7,%eax
mov    %eax,-0x68(%rbp)
jmp    1840 <constrain_ptypes+0x6d0>
movsbl -0x49(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x30(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     189c <constrain_ptypes+0x72c>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1869 <constrain_ptypes+0x6f9>
jmp    18a1 <constrain_ptypes+0x731>
jmp    18a6 <constrain_ptypes+0x736>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15b1 <constrain_ptypes+0x441>
jmp    18b9 <constrain_ptypes+0x749>
cmpl   $0x0,-0x40(%rbp)
je     18e8 <constrain_ptypes+0x778>
mov    0x2716(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0x729(%rip),%rsi
call   1050 <fprintf@plt>
lea    0x766(%rip),%rdi
call   1060 <vrna_message_error@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<constrain_ptypes>:
test   %rdi,%rdi
je     1700 <constrain_ptypes+0x590>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9d,%ebx
mov    %rcx,%rbp
mov    %rdx,%r12
mov    %r8d,0x8(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,0x78(%rsp)
call   1040 <strlen@plt>
mov    %rax,%r14
shl    $0x20,%rax
movabs $0x100000000,%rdi
add    %rax,%rdi
shr    $0x1e,%rdi
call   1080 <vrna_alloc@plt>
mov    %rax,0x48(%rsp)
test   %ebx,%ebx
je     1701 <constrain_ptypes+0x591>
mov    0x28(%rsp),%r15
mov    %r15d,%edi
call   1070 <vrna_idx_row_wise@plt>
mov    %rax,%rbx
test   %r14d,%r14d
jle    1d56 <constrain_ptypes+0xbe6>
mov    $0x1,%ecx
mov    0x8(%rsp),%eax
sub    %eax,%ecx
movslq %r15d,%rdx
mov    %rdx,0x40(%rsp)
movslq %eax,%rdx
lea    0x1(%r14),%eax
mov    %rax,0x50(%rsp)
lea    0x1(%r15),%r13d
lea    0x2(%rdx),%esi
mov    %rdx,%rax
mov    %rdx,0x8(%rsp)
mov    %edx,%r11d
neg    %r11b
mov    $0x2,%ebp
mov    $0x1,%r14d
xor    %eax,%eax
mov    %rax,0x70(%rsp)
movl   $0xffffffff,0x60(%rsp)
ff
mov    %r15d,%r10d
movl   $0x0,0x4(%rsp)
mov    0x78(%rsp),%r9
mov    %r15,%r8
jmp    127d <constrain_ptypes+0x10d>
nopl   (%rax)
add    $0x1,%r14
add    $0x1,%ebp
mov    0x24(%rsp),%ecx
add    $0x1,%ecx
addl   $0xffffffff,0x60(%rsp)
add    $0x3,%r10b
mov    0x68(%rsp),%esi
add    $0x1,%esi
add    $0x1,%r11b
cmp    0x50(%rsp),%r14
je     1d2a <constrain_ptypes+0xbba>
mov    0x70(%rsp),%rax
mov    %eax,%edi
mov    %esi,0x68(%rsp)
movslq %esi,%rax
mov    %r12,%r15
sub    %rax,%r15
movzbl %r11b,%r11d
and    $0x3,%r11d
mov    %ecx,0x24(%rsp)
mov    %ecx,%edx
lea    -0x1(%rdx),%rax
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
movzbl %r10b,%r10d
and    $0x3,%r10d
add    $0xfffffffffffffffe,%rdx
mov    %rdi,0x58(%rsp)
lea    0x1(%rdi),%esi
mov    %rsi,0x70(%rsp)
movsbl -0x1(%r14,%r9,1),%esi
lea    -0x28(%rsi),%edi
cmp    $0x16,%edi
ja     13a0 <constrain_ptypes+0x230>
lea    0xd24(%rip),%rsi
mov    %r10d,0x18(%rsp)
mov    %rsi,%r10
movslq (%rsi,%rdi,4),%rsi
add    %r10,%rsi
mov    0x18(%rsp),%r10d
jmp    *%rsi
mov    0x4(%rsp),%edi
movslq %edi,%rsi
add    $0x1,%edi
mov    %edi,0x4(%rsp)
mov    0x48(%rsp),%rdi
mov    %r14d,(%rdi,%rsi,4)
mov    %r14,%rsi
sub    0x8(%rsp),%rsi
cmp    $0x2,%rsi
jl     1250 <constrain_ptypes+0xe0>
mov    $0x1,%esi
cmp    $0x3,%rdx
jb     1371 <constrain_ptypes+0x201>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movslq 0x4(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0x8(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0xc(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0x10(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1330 <constrain_ptypes+0x1c0>
add    $0x1,%rsi
test   $0x3,%al
je     1250 <constrain_ptypes+0xe0>
lea    (%rbx,%rsi,4),%rax
xor    %ecx,%ecx
nop
movslq (%rax,%rcx,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1380 <constrain_ptypes+0x210>
jmp    1250 <constrain_ptypes+0xe0>
nopw   0x0(%rax,%rax,1)
cmp    $0x78,%esi
jne    1250 <constrain_ptypes+0xe0>
mov    %r14,%rsi
sub    0x8(%rsp),%rsi
cmp    $0x2,%rsi
jl     1435 <constrain_ptypes+0x2c5>
mov    $0x1,%esi
cmp    $0x3,%rdx
jb     1411 <constrain_ptypes+0x2a1>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x4(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0x8(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0xc(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0x10(%rbx,%rsi,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    13d0 <constrain_ptypes+0x260>
add    $0x1,%rsi
test   $0x3,%al
je     1435 <constrain_ptypes+0x2c5>
lea    (%rbx,%rsi,4),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movslq (%rax,%rcx,4),%rdx
sub    %r14,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1420 <constrain_ptypes+0x2b0>
mov    0x8(%rsp),%rax
add    %r14,%rax
cmp    0x40(%rsp),%rax
jge    1250 <constrain_ptypes+0xe0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
movslq (%rbx,%r14,4),%rcx
movb   $0x0,(%r15,%rcx,1)
add    $0xffffffffffffffff,%r15
cmp    %r8d,%eax
jl     1450 <constrain_ptypes+0x2e0>
jmp    1250 <constrain_ptypes+0xe0>
mov    0x4(%rsp),%eax
test   %eax,%eax
mov    %r11,0x80(%rsp)
jg     14af <constrain_ptypes+0x33f>
mov    0x2b5f(%rip),%rax
mov    (%rax),%edi
lea    0xc2e(%rip),%rsi
mov    %r9,%rdx
call   1050 <fprintf@plt>
lea    0xc45(%rip),%rdi
call   1060 <vrna_message_error@plt>
mov    0x80(%rsp),%r11
mov    0x4(%rsp),%eax
mov    0x28(%rsp),%r8
cltq
mov    0x48(%rsp),%rcx
mov    -0x4(%rcx,%rax,4),%eax
mov    %rax,0x10(%rsp)
movslq %eax,%r9
movslq (%rbx,%r9,4),%rcx
sub    %r14,%rcx
mov    (%r12,%rcx,1),%al
mov    %al,0x38(%rsp)
cmp    %r9,%r14
mov    0x40(%rsp),%rax
jge    163a <constrain_ptypes+0x4ca>
cmpl   $0x0,0x10(%rsp)
jle    15d0 <constrain_ptypes+0x460>
mov    0x10(%rsp),%rdi
lea    0x1(%rdi),%rsi
mov    %ebp,%eax
sub    %edi,%eax
mov    0x70(%rsp),%rcx
mov    %ecx,%edx
sub    %edi,%edx
mov    %edi,%ecx
neg    %ecx
mov    %ecx,0x58(%rsp)
mov    %ebp,%ecx
sub    %dil,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
mov    %ecx,0x30(%rsp)
mov    $0x1,%ecx
jmp    152d <constrain_ptypes+0x3bd>
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %rsi,%rcx
je     15d0 <constrain_ptypes+0x460>
cmp    %r9,%r14
jl     1520 <constrain_ptypes+0x3b0>
mov    0x10(%rsp),%r10
test   $0x3,%al
je     1574 <constrain_ptypes+0x404>
mov    0x30(%rsp),%r11d
mov    0x58(%rsp),%edi
mov    %edi,%r10d
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%r8d
add    %r10d,%r8d
movslq %r8d,%rdi
movb   $0x0,(%r12,%rdi,1)
add    $0xffffffff,%r10d
add    $0xffffffff,%r11d
jne    1550 <constrain_ptypes+0x3e0>
neg    %r10d
mov    0x80(%rsp),%r11
cmp    $0x3,%edx
jb     1520 <constrain_ptypes+0x3b0>
neg    %r10d
nopl   0x0(%rax)
mov    (%rbx,%rcx,4),%edi
add    %r10d,%edi
movslq %edi,%rdi
movb   $0x0,(%r12,%rdi,1)
mov    (%rbx,%rcx,4),%edi
add    %r10d,%edi
add    $0xffffffff,%edi
movslq %edi,%rdi
movb   $0x0,(%r12,%rdi,1)
mov    (%rbx,%rcx,4),%edi
lea    -0x2(%r10,%rdi,1),%edi
movslq %edi,%rdi
movb   $0x0,(%r12,%rdi,1)
mov    (%rbx,%rcx,4),%edi
add    %r10d,%edi
add    $0xfffffffd,%edi
movslq %edi,%rdi
movb   $0x0,(%r12,%rdi,1)
add    $0xfffffffc,%r10d
mov    %ebp,%edi
add    %r10d,%edi
jne    1580 <constrain_ptypes+0x410>
jmp    1520 <constrain_ptypes+0x3b0>
addl   $0xffffffff,0x4(%rsp)
mov    0x38(%rsp),%al
test   %al,%al
movzbl %al,%ecx
mov    $0x7,%eax
cmove  %eax,%ecx
movslq (%rbx,%r9,4),%rax
sub    %r14,%rax
mov    %cl,(%r12,%rax,1)
mov    0x78(%rsp),%r9
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%r10d
mov    0x8(%rsp),%rax
add    %r14,%rax
cmp    0x40(%rsp),%rax
jge    1250 <constrain_ptypes+0xe0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%eax
movslq (%rbx,%r14,4),%rcx
movb   $0x0,(%r15,%rcx,1)
add    $0xffffffffffffffff,%r15
cmp    %r8d,%eax
jl     1620 <constrain_ptypes+0x4b0>
jmp    1250 <constrain_ptypes+0xe0>
mov    %r8d,%r10d
mov    0x58(%rsp),%rcx
sub    %ecx,%r10d
not    %ecx
add    %r8d,%ecx
mov    %rcx,%r8
mov    %r9,%rcx
jmp    166c <constrain_ptypes+0x4fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %ecx,%ebp
je     14df <constrain_ptypes+0x36f>
cmp    %rax,%r14
jg     1660 <constrain_ptypes+0x4f0>
mov    %r14d,%esi
test   $0x3,%r10b
je     16a7 <constrain_ptypes+0x537>
mov    0x18(%rsp),%edi
mov    0x60(%rsp),%edx
mov    %edx,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rcx,4),%edx
add    %esi,%edx
movslq %edx,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0xffffffff,%esi
add    $0xffffffff,%edi
jne    1690 <constrain_ptypes+0x520>
neg    %esi
cmp    $0x3,%r8d
jb     1660 <constrain_ptypes+0x4f0>
not    %esi
nop
mov    (%rbx,%rcx,4),%edx
add    %esi,%edx
add    $0x1,%edx
movslq %edx,%rdx
movb   $0x0,(%r12,%rdx,1)
mov    (%rbx,%rcx,4),%edx
add    %esi,%edx
movslq %edx,%rdx
movb   $0x0,(%r12,%rdx,1)
mov    (%rbx,%rcx,4),%edx
add    %esi,%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
movb   $0x0,(%r12,%rdx,1)
mov    (%rbx,%rcx,4),%edx
lea    -0x2(%rsi,%rdx,1),%edx
movslq %edx,%rdx
movb   $0x0,(%r12,%rdx,1)
lea    (%rsi,%r13,1),%edx
add    $0xfffffffc,%edx
add    $0xfffffffc,%esi
cmp    $0xffffffff,%edx
jne    16b0 <constrain_ptypes+0x540>
jmp    1660 <constrain_ptypes+0x4f0>
ret
mov    %rbp,0x40(%rsp)
mov    0x28(%rsp),%rbp
mov    %ebp,%edi
call   1090 <vrna_idx_col_wise@plt>
mov    %rax,%rbx
test   %r14d,%r14d
jle    1d56 <constrain_ptypes+0xbe6>
lea    0x1(%rbp),%eax
mov    %rax,0x68(%rsp)
movslq %ebp,%rax
mov    %rax,0x50(%rsp)
mov    0x8(%rsp),%r11d
movslq %r11d,%rax
mov    %rax,0x30(%rsp)
lea    0x1(%r14),%eax
mov    %rax,0x80(%rsp)
mov    %r11d,%eax
not    %eax
mov    %rax,0x58(%rsp)
lea    0x4(%r12),%rax
mov    %rax,0x38(%rsp)
mov    %r11d,%ecx
neg    %ecx
mov    $0x2,%r15d
mov    $0x1,%r13d
xor    %esi,%esi
movl   $0x0,0x10(%rsp)
mov    %r11d,%edi
movl   $0x0,0x4(%rsp)
mov    0x78(%rsp),%r9
mov    %rbp,%r10
jmp    17ba <constrain_ptypes+0x64a>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1,%r15d
mov    0x18(%rsp),%rsi
add    $0x1,%rsi
mov    0x70(%rsp),%ecx
add    $0x1,%ecx
cmp    0x80(%rsp),%r13
mov    0x24(%rsp),%edi
je     1d2a <constrain_ptypes+0xbba>
mov    0x10(%rsp),%eax
mov    %eax,%ebp
mov    %ecx,%eax
and    $0x3,%eax
mov    %ecx,0x70(%rsp)
mov    %ecx,%edx
and    $0xfffffffc,%edx
neg    %edx
mov    %esi,%r8d
sub    %r11d,%r8d
mov    0x58(%rsp),%rcx
mov    %rsi,0x18(%rsp)
add    %ecx,%esi
mov    %rbp,0x60(%rsp)
lea    0x1(%rbp),%ecx
mov    %ecx,0x10(%rsp)
add    $0x1,%edi
mov    %edi,0x24(%rsp)
movslq %edi,%r14
movsbl -0x1(%r13,%r9,1),%edi
lea    -0x28(%rdi),%ebp
cmp    $0x16,%ebp
ja     18d0 <constrain_ptypes+0x760>
lea    0x84b(%rip),%rcx
movslq (%rcx,%rbp,4),%rdi
add    %rcx,%rdi
jmp    *%rdi
mov    0x4(%rsp),%edi
movslq %edi,%rcx
add    $0x1,%edi
mov    %edi,0x4(%rsp)
mov    0x48(%rsp),%rdi
mov    %r13d,(%rdi,%rcx,4)
mov    %r13,%rcx
sub    0x30(%rsp),%rcx
cmp    $0x2,%rcx
jl     1790 <constrain_ptypes+0x620>
mov    $0x1,%ebp
cmp    $0x3,%esi
jb     1899 <constrain_ptypes+0x729>
mov    $0x1,%edi
mov    0x38(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movslq (%rbx,%r13,4),%rcx
movb   $0x0,-0x3(%rsi,%rcx,1)
movslq (%rbx,%r13,4),%rcx
movb   $0x0,-0x2(%rsi,%rcx,1)
movslq (%rbx,%r13,4),%rcx
movb   $0x0,-0x1(%rsi,%rcx,1)
movslq (%rbx,%r13,4),%rcx
movb   $0x0,(%rsi,%rcx,1)
add    $0x4,%rsi
mov    %edi,%ebp
add    $0x4,%ebp
lea    (%rdx,%rdi,1),%ecx
add    $0x4,%ecx
mov    %ebp,%edi
cmp    $0x1,%ecx
jne    1860 <constrain_ptypes+0x6f0>
test   $0x3,%r8b
je     1790 <constrain_ptypes+0x620>
movslq %ebp,%rcx
add    %r12,%rcx
nopl   0x0(%rax)
movslq (%rbx,%r13,4),%rdx
movb   $0x0,(%rcx,%rdx,1)
add    $0x1,%rcx
add    $0xffffffff,%eax
jne    18b0 <constrain_ptypes+0x740>
jmp    1790 <constrain_ptypes+0x620>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x7c,%edi
je     1b9b <constrain_ptypes+0xa2b>
cmp    $0x78,%edi
jne    1790 <constrain_ptypes+0x620>
mov    %r13,%rdi
sub    0x30(%rsp),%rdi
cmp    $0x2,%rdi
jl     1971 <constrain_ptypes+0x801>
mov    $0x1,%ebp
cmp    $0x3,%esi
jb     1949 <constrain_ptypes+0x7d9>
mov    $0x1,%edi
mov    0x38(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movslq (%rbx,%r13,4),%rbp
movb   $0x0,-0x3(%rsi,%rbp,1)
movslq (%rbx,%r13,4),%rbp
movb   $0x0,-0x2(%rsi,%rbp,1)
movslq (%rbx,%r13,4),%rbp
movb   $0x0,-0x1(%rsi,%rbp,1)
movslq (%rbx,%r13,4),%rbp
movb   $0x0,(%rsi,%rbp,1)
add    $0x4,%rsi
mov    %edi,%ebp
add    $0x4,%ebp
lea    (%rdx,%rdi,1),%ecx
add    $0x4,%ecx
mov    %ebp,%edi
cmp    $0x1,%ecx
jne    1910 <constrain_ptypes+0x7a0>
test   $0x3,%r8b
je     1971 <constrain_ptypes+0x801>
movslq %ebp,%rcx
add    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%rbx,%r13,4),%rdx
movb   $0x0,(%rcx,%rdx,1)
add    $0x1,%rcx
add    $0xffffffff,%eax
jne    1960 <constrain_ptypes+0x7f0>
mov    0x30(%rsp),%rax
add    %r13,%rax
mov    0x50(%rsp),%rcx
cmp    %rcx,%rax
jge    1790 <constrain_ptypes+0x620>
nopw   0x0(%rax,%rax,1)
movslq 0x4(%rbx,%r14,4),%rax
add    $0x1,%r14
add    %r13,%rax
movb   $0x0,(%r12,%rax,1)
cmp    %rcx,%r14
jl     1990 <constrain_ptypes+0x820>
jmp    1790 <constrain_ptypes+0x620>
mov    0x4(%rsp),%ebp
test   %ebp,%ebp
jg     19dc <constrain_ptypes+0x86c>
mov    0x2626(%rip),%rax
mov    (%rax),%edi
lea    0x6f5(%rip),%rsi
mov    %r9,%rdx
call   1050 <fprintf@plt>
lea    0x6ea(%rip),%rdi
call   1060 <vrna_message_error@plt>
mov    0x28(%rsp),%r10
movslq %ebp,%rax
mov    0x48(%rsp),%rcx
movslq -0x4(%rcx,%rax,4),%rcx
movslq (%rbx,%r13,4),%rax
add    %rcx,%rax
mov    (%r12,%rax,1),%r8b
cmp    %r10d,%ecx
mov    0x68(%rsp),%rdi
jge    1a7b <constrain_ptypes+0x90b>
lea    0x1(%rcx),%rax
mov    %r10d,%esi
sub    %ecx,%esi
mov    %ecx,%edx
not    %edx
add    %r10d,%edx
and    $0x3,%esi
je     1a35 <constrain_ptypes+0x8c5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq (%rbx,%rax,4),%rdi
add    %rcx,%rdi
movb   $0x0,(%r12,%rdi,1)
add    $0x1,%rax
add    $0xffffffff,%esi
jne    1a20 <constrain_ptypes+0x8b0>
cmp    $0x3,%edx
mov    0x68(%rsp),%rdi
jb     1a7b <constrain_ptypes+0x90b>
nop
movslq (%rbx,%rax,4),%rdx
add    %rcx,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0x4(%rbx,%rax,4),%rdx
add    %rcx,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0x8(%rbx,%rax,4),%rdx
add    %rcx,%rdx
movb   $0x0,(%r12,%rdx,1)
movslq 0xc(%rbx,%rax,4),%rdx
add    %rcx,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0x4,%rax
cmp    %eax,%edi
jne    1a40 <constrain_ptypes+0x8d0>
cmp    0x50(%rsp),%r13
jle    1bb6 <constrain_ptypes+0xa46>
cmp    %rcx,%r13
mov    0x8(%rsp),%r11d
jge    1c69 <constrain_ptypes+0xaf9>
cmp    $0x2,%r13
mov    0x78(%rsp),%r9
mov    0x28(%rsp),%r10
mov    0x60(%rsp),%rbp
jb     1b42 <constrain_ptypes+0x9d2>
mov    0x18(%rsp),%rsi
lea    -0x1(%rsi),%rdx
mov    $0x1,%eax
cmp    $0x3,%rdx
jb     1b1c <constrain_ptypes+0x9ac>
mov    %rsi,%rax
and    $0xfffffffffffffffc,%rax
neg    %rax
mov    0x38(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rbx,%r13,4),%rdi
movb   $0x0,-0x3(%rsi,%rdi,1)
movslq (%rbx,%r13,4),%rdi
movb   $0x0,-0x2(%rsi,%rdi,1)
movslq (%rbx,%r13,4),%rdi
movb   $0x0,-0x1(%rsi,%rdi,1)
movslq (%rbx,%r13,4),%rdi
movb   $0x0,(%rsi,%rdi,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rsi
cmp    %rdx,%rax
jne    1ae0 <constrain_ptypes+0x970>
mov    $0x1,%eax
sub    %edx,%eax
mov    0x18(%rsp),%rsi
test   $0x3,%sil
je     1b42 <constrain_ptypes+0x9d2>
and    $0x3,%ebp
cltq
add    %r12,%rax
nopw   0x0(%rax,%rax,1)
movslq (%rbx,%r13,4),%rdx
movb   $0x0,(%rax,%rdx,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    1b30 <constrain_ptypes+0x9c0>
addl   $0xffffffff,0x4(%rsp)
test   %r8b,%r8b
movzbl %r8b,%eax
mov    $0x7,%edx
cmove  %edx,%eax
movslq (%rbx,%r13,4),%rdx
add    %rcx,%rdx
mov    %al,(%r12,%rdx,1)
mov    0x30(%rsp),%rax
add    %r13,%rax
mov    0x50(%rsp),%rcx
cmp    %rcx,%rax
jge    1790 <constrain_ptypes+0x620>
nopw   0x0(%rax,%rax,1)
movslq 0x4(%rbx,%r14,4),%rax
add    $0x1,%r14
add    %r13,%rax
movb   $0x0,(%r12,%rax,1)
cmp    %rcx,%r14
jl     1b80 <constrain_ptypes+0xa10>
jmp    1790 <constrain_ptypes+0x620>
mov    0x40(%rsp),%rax
test   %rax,%rax
je     1790 <constrain_ptypes+0x620>
movl   $0xffffffff,(%rax,%r13,4)
ff
jmp    1790 <constrain_ptypes+0x620>
lea    0x1(%rcx),%edx
mov    0x10(%rsp),%r10d
sub    %ecx,%r10d
mov    0x60(%rsp),%rax
mov    %eax,%r11d
sub    %ecx,%r11d
mov    %r13d,%eax
sub    %cl,%al
movzbl %al,%r9d
and    $0x3,%r9d
mov    %r13,%rbp
jmp    1bed <constrain_ptypes+0xa7d>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %rdi,%rbp
je     1a86 <constrain_ptypes+0x916>
cmp    %rcx,%r13
jle    1be0 <constrain_ptypes+0xa70>
mov    %edx,%eax
test   $0x3,%r10b
je     1c15 <constrain_ptypes+0xaa5>
mov    %r9d,%esi
mov    %edx,%eax
nop
mov    (%rbx,%rbp,4),%edi
add    %eax,%edi
movslq %edi,%rdi
movb   $0x0,(%r12,%rdi,1)
add    $0x1,%eax
add    $0xffffffff,%esi
jne    1c00 <constrain_ptypes+0xa90>
cmp    $0x3,%r11d
mov    0x68(%rsp),%rdi
jb     1be0 <constrain_ptypes+0xa70>
mov    (%rbx,%rbp,4),%esi
add    %eax,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
mov    (%rbx,%rbp,4),%esi
add    %eax,%esi
add    $0x1,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
mov    (%rbx,%rbp,4),%esi
lea    0x2(%rax,%rsi,1),%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
mov    (%rbx,%rbp,4),%esi
add    %eax,%esi
add    $0x3,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
add    $0x4,%eax
cmp    %eax,%r15d
jne    1c20 <constrain_ptypes+0xab0>
jmp    1be0 <constrain_ptypes+0xa70>
lea    -0x1(%rcx),%r9d
mov    %ecx,%r10d
and    $0x3,%r10d
mov    %ecx,%edi
and    $0xfffffffc,%edi
neg    %edi
mov    %rcx,%rax
jmp    1c8d <constrain_ptypes+0xb1d>
add    $0x1,%rax
cmp    %eax,%r15d
je     1a94 <constrain_ptypes+0x924>
test   %ecx,%ecx
jle    1c80 <constrain_ptypes+0xb10>
mov    $0x1,%ebp
cmp    $0x3,%r9d
jb     1cff <constrain_ptypes+0xb8f>
mov    $0x2,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%esi
mov    %ebp,%edx
add    %edx,%esi
add    $0xffffffff,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
mov    (%rbx,%rax,4),%esi
add    %ebp,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
mov    (%rbx,%rax,4),%esi
add    %edx,%esi
add    $0x1,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
mov    (%rbx,%rax,4),%esi
add    %edx,%esi
add    $0x2,%esi
movslq %esi,%rsi
movb   $0x0,(%r12,%rsi,1)
add    $0x4,%ebp
add    %edi,%edx
add    $0x4,%edx
cmp    $0x2,%edx
jne    1cb0 <constrain_ptypes+0xb40>
add    $0xffffffff,%ebp
test   %r10d,%r10d
je     1c80 <constrain_ptypes+0xb10>
mov    %r10d,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%edx
add    %ebp,%edx
movslq %edx,%rdx
movb   $0x0,(%r12,%rdx,1)
add    $0x1,%ebp
add    $0xffffffff,%esi
jne    1d10 <constrain_ptypes+0xba0>
jmp    1c80 <constrain_ptypes+0xb10>
mov    0x4(%rsp),%eax
test   %eax,%eax
je     1d56 <constrain_ptypes+0xbe6>
mov    0x22a7(%rip),%rax
mov    (%rax),%edi
lea    0x376(%rip),%rsi
mov    %r9,%rdx
call   1050 <fprintf@plt>
lea    0x3b0(%rip),%rdi
call   1060 <vrna_message_error@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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