#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 */
scalar_t__ strcmp(char *, char *);
void get_mask_array(long long *aptr, int nflexible, int natoms, char **name,
                    long long *resid, long long *flexible_residues,
                    int nresidues, int mtype) {
  int i, j, q0, fr, value, count;
  long long value_array[natoms];
  long long(*farray)[natoms] = (long long(*)[natoms])aptr;
  for (i = 0; i < natoms; i++) {
    value_array[i] = 0;
  }
  for (i = 0; i < nflexible; i++) {
    for (j = 0; j < natoms; j++) {
      farray[i][j] = 0;
    }
  }
  count = 0;
  if (mtype == 0) {
    for (fr = 0; fr < nflexible; fr++) {
      q0 = flexible_residues[fr];
      for (i = 0; i < natoms; i++) {
        value = 0;
        if (resid[i] < q0 - 1 || resid[i] > q0 + 1) {
          count++;
          value_array[i] = 0;
          continue;
        }
        if (resid[i] == q0 - 1 && (strcmp(name[i], "C") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "N") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "CA") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "C") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 + 1 && (strcmp(name[i], "N") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else {
          value_array[i] = value;
        }
      }
      for (i = 0; i < natoms; i++) {
        farray[fr][i] = value_array[i];
      }
    }
  } else if (mtype == 1) {
    for (fr = 0; fr < nflexible; fr++) {
      q0 = flexible_residues[fr];
      for (i = 0; i < natoms; i++) {
        value = 0;
        if (resid[i] < q0 - 1 || resid[i] > q0 + 1) {
          count++;
          value_array[i] = 0;
          continue;
        }
        if (resid[i] == q0 - 1 && (strcmp(name[i], "O3'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "P") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "O5'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "C5'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "C4'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "C3'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 && (strcmp(name[i], "O3'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 + 1 && (strcmp(name[i], "P") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else if (resid[i] == q0 + 1 && (strcmp(name[i], "O5'") == 0)) {
          value = 1;
          count++;
          value_array[i] = value;
        } else {
          value_array[i] = value;
        }
      }
      for (i = 0; i < natoms; i++) {
        farray[fr][i] = value_array[i];
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<get_mask_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x48(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%eax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    119b <get_mask_array+0x8b>
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1171 <get_mask_array+0x61>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1205 <get_mask_array+0xf5>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11f2 <get_mask_array+0xe2>
mov    -0x60(%rbp),%rdx
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11b5 <get_mask_array+0xa5>
jmp    11f7 <get_mask_array+0xe7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a2 <get_mask_array+0x92>
movl   $0x0,-0x40(%rbp)
cmpl   $0x0,0x18(%rbp)
jne    1531 <get_mask_array+0x421>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    152c <get_mask_array+0x41c>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14cd <get_mask_array+0x3bd>
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     128e <get_mask_array+0x17e>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    12ac <get_mask_array+0x19c>
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x2c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
jmp    14bf <get_mask_array+0x3af>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    1311 <get_mask_array+0x201>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd23(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1311 <get_mask_array+0x201>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14ba <get_mask_array+0x3aa>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    1371 <get_mask_array+0x261>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcc5(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1371 <get_mask_array+0x261>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14b5 <get_mask_array+0x3a5>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    13d1 <get_mask_array+0x2c1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc67(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    13d1 <get_mask_array+0x2c1>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14b0 <get_mask_array+0x3a0>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    1431 <get_mask_array+0x321>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc03(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1431 <get_mask_array+0x321>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14ab <get_mask_array+0x39b>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    1496 <get_mask_array+0x386>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xba0(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1496 <get_mask_array+0x386>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14a6 <get_mask_array+0x396>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14ab <get_mask_array+0x39b>
jmp    14b0 <get_mask_array+0x3a0>
jmp    14b5 <get_mask_array+0x3a5>
jmp    14ba <get_mask_array+0x3aa>
jmp    14bf <get_mask_array+0x3af>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123f <get_mask_array+0x12f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1519 <get_mask_array+0x409>
mov    -0x60(%rbp),%rsi
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d4 <get_mask_array+0x3c4>
jmp    151e <get_mask_array+0x40e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    121d <get_mask_array+0x10d>
jmp    19f4 <get_mask_array+0x8e4>
cmpl   $0x1,0x18(%rbp)
jne    19ef <get_mask_array+0x8df>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19ea <get_mask_array+0x8da>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    198b <get_mask_array+0x87b>
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     15b3 <get_mask_array+0x4a3>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    15d1 <get_mask_array+0x4c1>
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x2c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
jmp    197d <get_mask_array+0x86d>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    1636 <get_mask_array+0x526>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa05(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1636 <get_mask_array+0x526>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1978 <get_mask_array+0x868>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    1696 <get_mask_array+0x586>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x9a9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1696 <get_mask_array+0x586>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1973 <get_mask_array+0x863>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    16f6 <get_mask_array+0x5e6>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x94b(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    16f6 <get_mask_array+0x5e6>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    196e <get_mask_array+0x85e>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    1756 <get_mask_array+0x646>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8ef(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1756 <get_mask_array+0x646>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1969 <get_mask_array+0x859>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    17b6 <get_mask_array+0x6a6>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x893(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    17b6 <get_mask_array+0x6a6>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1964 <get_mask_array+0x854>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    1816 <get_mask_array+0x706>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x837(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1816 <get_mask_array+0x706>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    195f <get_mask_array+0x84f>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
jne    1876 <get_mask_array+0x766>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x7c5(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1876 <get_mask_array+0x766>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    195a <get_mask_array+0x84a>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    18db <get_mask_array+0x7cb>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x764(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    18db <get_mask_array+0x7cb>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1955 <get_mask_array+0x845>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    1940 <get_mask_array+0x830>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x701(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1940 <get_mask_array+0x830>
mov    -0x68(%rbp),%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1950 <get_mask_array+0x840>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1955 <get_mask_array+0x845>
jmp    195a <get_mask_array+0x84a>
jmp    195f <get_mask_array+0x84f>
jmp    1964 <get_mask_array+0x854>
jmp    1969 <get_mask_array+0x859>
jmp    196e <get_mask_array+0x85e>
jmp    1973 <get_mask_array+0x863>
jmp    1978 <get_mask_array+0x868>
jmp    197d <get_mask_array+0x86d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1564 <get_mask_array+0x454>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19d7 <get_mask_array+0x8c7>
mov    -0x60(%rbp),%rsi
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1992 <get_mask_array+0x882>
jmp    19dc <get_mask_array+0x8cc>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1542 <get_mask_array+0x432>
jmp    19ef <get_mask_array+0x8df>
jmp    19f4 <get_mask_array+0x8e4>
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_mask_array>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,-0x80(%rbp)
mov    %r8,%r13
mov    %rcx,-0x30(%rbp)
mov    %edx,%r12d
mov    %esi,%r15d
mov    %rdi,-0x70(%rbp)
mov    %edx,%r14d
mov    %rsp,%rbx
lea    0xf(,%r14,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
test   %edx,%edx
jle    1184 <get_mask_array+0x54>
lea    0x0(,%r14,8),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %rbx,-0x78(%rbp)
mov    %r14,-0x48(%rbp)
mov    %r15d,-0x4c(%rbp)
test   %r15d,%r15d
mov    %r12d,-0x3c(%rbp)
jle    1202 <get_mask_array+0xd2>
mov    -0x48(%rbp),%rcx
lea    0x0(,%rcx,8),%rdx
mov    -0x4c(%rbp),%ebx
lea    -0x1(%rbx),%rax
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x3,%rax
mov    %rdx,-0x38(%rbp)
jae    165a <get_mask_array+0x52a>
xor    %r14d,%r14d
test   %r15,%r15
mov    -0x3c(%rbp),%r12d
je     1202 <get_mask_array+0xd2>
imul   -0x48(%rbp),%r14
mov    -0x70(%rbp),%rax
lea    (%rax,%r14,8),%rbx
jmp    11e9 <get_mask_array+0xb9>
nopl   0x0(%rax)
add    %rdx,%rbx
add    $0xffffffffffffffff,%r15
je     1202 <get_mask_array+0xd2>
test   %r12d,%r12d
jle    11e0 <get_mask_array+0xb0>
mov    %rbx,%rdi
xor    %esi,%esi
mov    -0x38(%rbp),%rdx
call   1030 <memset@plt>
mov    -0x38(%rbp),%rdx
jmp    11e0 <get_mask_array+0xb0>
mov    0x18(%rbp),%eax
test   %eax,%eax
je     148b <get_mask_array+0x35b>
cmp    $0x1,%eax
mov    -0x48(%rbp),%r14
mov    -0x4c(%rbp),%ecx
jne    164b <get_mask_array+0x51b>
test   %ecx,%ecx
jle    164b <get_mask_array+0x51b>
lea    0x0(,%r14,8),%rax
mov    %rax,-0x58(%rbp)
mov    %ecx,%eax
mov    %rax,-0x68(%rbp)
xor    %ebx,%ebx
jmp    124e <get_mask_array+0x11e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    -0x68(%rbp),%rbx
je     164b <get_mask_array+0x51b>
test   %r12d,%r12d
jle    1240 <get_mask_array+0x110>
mov    %rbx,%rax
imul   %r14,%rax
mov    -0x70(%rbp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x80(%rbp),%rax
mov    %rbx,-0x38(%rbp)
mov    (%rax,%rbx,8),%r12
movslq %r12d,%rbx
shl    $0x20,%r12
movabs $0xffffffff00000000,%rax
ff ff ff
lea    (%r12,%rax,1),%r14
sar    $0x20,%r14
movabs $0x100000000,%rax
add    %rax,%r12
sar    $0x20,%r12
xor    %r15d,%r15d
jmp    12cb <get_mask_array+0x19b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ecx
mov    -0x78(%rbp),%rax
mov    %rcx,(%rax,%r15,8)
add    $0x1,%r15
cmp    %r15,-0x48(%rbp)
je     1460 <get_mask_array+0x330>
mov    0x0(%r13,%r15,8),%rax
cmp    %r14,%rax
jl     1450 <get_mask_array+0x320>
mov    $0x0,%ecx
cmp    %r12,%rax
jg     12b5 <get_mask_array+0x185>
cmp    %r14,%rax
jne    1306 <get_mask_array+0x1d6>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xd10(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
jne    1329 <get_mask_array+0x1f9>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xcf1(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
jne    1350 <get_mask_array+0x220>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xcd0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
jne    1377 <get_mask_array+0x247>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xcad(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
jne    139e <get_mask_array+0x26e>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xc8a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
jne    13f8 <get_mask_array+0x2c8>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xc67(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
je     13fd <get_mask_array+0x2cd>
cmp    %r12,%rax
jne    1424 <get_mask_array+0x2f4>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xc2d(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %r12,%rax
jne    1450 <get_mask_array+0x320>
jmp    1429 <get_mask_array+0x2f9>
cmp    %rbx,%rax
jne    13ca <get_mask_array+0x29a>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xbfb(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
mov    0x0(%r13,%r15,8),%rax
cmp    %r12,%rax
je     13cf <get_mask_array+0x29f>
cmp    %r12,%rax
jne    1450 <get_mask_array+0x320>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xbd5(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     12b0 <get_mask_array+0x180>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
jmp    12b5 <get_mask_array+0x185>
nopw   0x0(%rax,%rax,1)
mov    -0x3c(%rbp),%r12d
test   %r12d,%r12d
mov    -0x48(%rbp),%r14
mov    -0x78(%rbp),%rsi
mov    -0x38(%rbp),%rbx
jle    1240 <get_mask_array+0x110>
mov    -0x60(%rbp),%rdi
mov    -0x58(%rbp),%rdx
call   1050 <memcpy@plt>
jmp    1240 <get_mask_array+0x110>
mov    -0x4c(%rbp),%ecx
test   %ecx,%ecx
mov    -0x48(%rbp),%r14
jle    164b <get_mask_array+0x51b>
lea    0x0(,%r14,8),%rax
mov    %rax,-0x58(%rbp)
mov    %ecx,%eax
mov    %rax,-0x68(%rbp)
xor    %ebx,%ebx
jmp    14be <get_mask_array+0x38e>
add    $0x1,%rbx
cmp    -0x68(%rbp),%rbx
je     164b <get_mask_array+0x51b>
test   %r12d,%r12d
jle    14b0 <get_mask_array+0x380>
mov    %rbx,%rax
imul   %r14,%rax
mov    -0x70(%rbp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x80(%rbp),%rax
mov    %rbx,-0x38(%rbp)
mov    (%rax,%rbx,8),%r12
movslq %r12d,%r14
shl    $0x20,%r12
movabs $0xffffffff00000000,%rax
ff ff ff
lea    (%r12,%rax,1),%rbx
sar    $0x20,%rbx
movabs $0x100000000,%rax
add    %rax,%r12
sar    $0x20,%r12
xor    %r15d,%r15d
jmp    1538 <get_mask_array+0x408>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    -0x78(%rbp),%rax
mov    %rcx,(%rax,%r15,8)
add    $0x1,%r15
cmp    %r15,-0x48(%rbp)
je     1620 <get_mask_array+0x4f0>
mov    0x0(%r13,%r15,8),%rax
cmp    %rbx,%rax
jl     1520 <get_mask_array+0x3f0>
mov    $0x0,%ecx
cmp    %r12,%rax
jg     1522 <get_mask_array+0x3f2>
cmp    %rbx,%rax
jne    1573 <get_mask_array+0x443>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xaa0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1610 <get_mask_array+0x4e0>
mov    0x0(%r13,%r15,8),%rax
cmp    %r14,%rax
jne    1596 <get_mask_array+0x466>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xa7b(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1610 <get_mask_array+0x4e0>
mov    0x0(%r13,%r15,8),%rax
cmp    %r14,%rax
jne    15b9 <get_mask_array+0x489>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xa5a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1610 <get_mask_array+0x4e0>
mov    0x0(%r13,%r15,8),%rax
cmp    %r14,%rax
jne    15dc <get_mask_array+0x4ac>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xa33(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1610 <get_mask_array+0x4e0>
mov    0x0(%r13,%r15,8),%rax
cmp    %r12,%rax
jne    1520 <get_mask_array+0x3f0>
mov    -0x30(%rbp),%rax
mov    (%rax,%r15,8),%rdi
lea    0xa0e(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1520 <get_mask_array+0x3f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%ecx
jmp    1522 <get_mask_array+0x3f2>
nopw   0x0(%rax,%rax,1)
mov    -0x3c(%rbp),%r12d
test   %r12d,%r12d
mov    -0x48(%rbp),%r14
mov    -0x78(%rbp),%rsi
mov    -0x38(%rbp),%rbx
jle    14b0 <get_mask_array+0x380>
mov    -0x60(%rbp),%rdi
mov    -0x58(%rbp),%rdx
call   1050 <memcpy@plt>
jmp    14b0 <get_mask_array+0x380>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%ebx
mov    %rcx,%rax
shl    $0x5,%rax
mov    %rax,-0x68(%rbp)
shl    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
lea    (%rdx,%rdx,2),%rax
mov    %rax,-0x58(%rbp)
xor    %r14d,%r14d
mov    -0x70(%rbp),%r12
jmp    16a1 <get_mask_array+0x571>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x4,%r14
add    -0x68(%rbp),%r12
cmp    %r14,%rbx
je     11c4 <get_mask_array+0x94>
cmpl   $0x0,-0x3c(%rbp)
jle    1690 <get_mask_array+0x560>
mov    %r12,%rdi
xor    %esi,%esi
mov    -0x38(%rbp),%rdx
call   1030 <memset@plt>
mov    -0x38(%rbp),%rax
lea    (%r12,%rax,1),%rdi
xor    %esi,%esi
mov    -0x38(%rbp),%rdx
call   1030 <memset@plt>
mov    -0x60(%rbp),%rax
lea    (%r12,%rax,1),%rdi
xor    %esi,%esi
mov    -0x38(%rbp),%rdx
call   1030 <memset@plt>
mov    -0x58(%rbp),%rax
lea    (%r12,%rax,1),%rdi
xor    %esi,%esi
mov    -0x38(%rbp),%rdx
call   1030 <memset@plt>
mov    -0x38(%rbp),%rdx
jmp    1690 <get_mask_array+0x560>

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

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