int rdsmv(char *filename, char **head, int *lhead, char **array, int *naxis,
          int *axis, int *type) {
  int readl;
  int i, j, k;
  int istat, bo, dim;
  char s[80], s1[80];
  int lun = 1;
  int lflag;
  int nelm;
  char *thead;
  int filec_debug = filec_getdebug();
  *head = 0;
  *array = 0;
  j = strlen(filename);
  if (filec_debug)
    printf("Opening file: %s\n", filename);
  dskbor_(&lun, filename, &j, &istat);
  if (istat != 0) {
    if (filec_debug)
      printf("Error opening file %s, istat=%d\n", filename, istat);
    return (-3);
  }
  lflag = (1 == 1);
  dskbwr_(&lun, &lflag);
  readl = 512;
  thead = malloc(512);
  memset(thead, 0, 512);
  if (filec_debug)
    printf("Reading header\n");
  dskbr_(&lun, thead, &readl, &istat);
  if (filec_debug)
    printf("Read Completion status : %d\n", istat);
  if (istat != 0) {
    istat = -2;
    goto close;
  }
  if ((istat = gethdl(&k, thead)) < 0) {
    istat = -4;
    goto close;
  }
  if (filec_debug)
    printf("Header length : %d\n", k);
  *lhead = ((k / 1024) + 1) * 1024;
  *head = malloc(*lhead);
  memset(*head, 0, *lhead);
  memcpy(*head, thead, 512);
  free(thead);
  readl = k - 512;
  if (readl > 0) {
    dskbr_(&lun, *head + 512, &readl, &istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
  }
  lflag = (1 == 0);
  dskbwr_(&lun, &lflag);
  *naxis = 0;
  gethd("DIM", s, *head);
  if (*s == 0 || sscanf(s, "%d", &dim) != 1) {
    if (filec_debug)
      printf("Error reading dimensions\n");
    goto close;
  }
  if (filec_debug)
    printf("Number of dimensions : %d\n", dim);
  *naxis = dim;
  for (i = 0, nelm = 1; i < dim; i++) {
    sprintf(s1, "SIZE%d", i + 1);
    gethd(s1, s, *head);
    if (*s == 0 || sscanf(s, "%d", &axis[i]) != 1) {
      if (filec_debug)
        printf("Error reading %s\n", s1);
      goto close;
    }
    nelm *= axis[i];
  }
  gethd("BYTE_ORDER", s, *head);
  if (*s) {
    if (strcmp(s, "little_endian") == 0)
      bo = 0;
    else if (strcmp(s, "big_endian") == 0)
      bo = 1;
    else {
      istat = -4;
      goto close;
    }
  } else
    bo = -1;
  gethd("TYPE", s, *head);
  if (filec_debug) {
    printf("Type >%s<\n", s);
    printf("Image size (%d)", dim);
    for (i = 0; i < dim; i++)
      printf(" %d ", axis[i]);
    printf("\n");
    printf("Number of elements : %d\n", nelm);
    if (bo)
      printf("Byte order : big_endian\n");
    else
      printf("Byte order : little_endian\n");
  }
  if (strcmp(s, "unsigned_byte") == 0 || strcmp(s, "byte") == 0 ||
      strcmp(s, "unsigned_char") == 0 || strcmp(s, "char") == 0) {
    int i;
    unsigned char *char_array, *cp;
    unsigned short *ap;
    if (filec_debug)
      printf("Reading byte image\n");
    readl = nelm * sizeof(char);
    char_array = malloc(readl);
    if (filec_debug) {
      printf("Allocating %d bytes for byte image\n", readl);
      printf("Reading unsigned byte image\n");
    }
    dskbr_(&lun, (char *)char_array, &readl, &istat);
    if (filec_debug)
      printf("Read Byte Completion status : %d\n", istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    lflag = (1 == 1);
    dskbwr_(&lun, &lflag);
    if (filec_debug) {
      readl = nelm * sizeof(unsigned short);
      printf("Allocating %d bytes for short image\n", readl);
    }
    *array = malloc(nelm * sizeof(unsigned short));
    *type = 4;
    ap = (unsigned short *)*array;
    cp = char_array;
    if (filec_debug)
      printf("Converting %d bytes to short image\n", nelm);
    for (i = 0; i < nelm; i++)
      *ap++ = *cp++;
    free(char_array);
  } else if (strcmp(s, "bit") == 0) {
    int i;
    unsigned char *bit_array, *bp;
    unsigned short *ap;
    if (filec_debug)
      printf("Reading bit image\n");
    readl = nelm * sizeof(char) / 8;
    bit_array = malloc(readl);
    if (filec_debug)
      printf("Reading bit image\n");
    dskbr_(&lun, (char *)bit_array, &readl, &istat);
    if (filec_debug)
      printf("Read Completion status : %d\n", istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    lflag = (1 == 1);
    dskbwr_(&lun, &lflag);
    *array = malloc(nelm * sizeof(unsigned short));
    *type = 4;
    ap = (unsigned short *)*array;
    bp = bit_array;
    for (i = 0; i < nelm; i += 8) {
      for (j = 0; j < 8; j++)
        *ap++ = *bp & 2 << j;
      bp++;
    }
    free(bit_array);
  } else if (strcmp(s, "mad") == 0 || strcmp(s, "unsigned_short") == 0) {
    if (filec_debug)
      printf("Reading unsigned short image\n");
    readl = nelm * sizeof(unsigned short);
    if (filec_debug) {
      printf("Reading unsigned short image\n");
      printf("Allocating %d bytes\n", readl);
    }
    *array = malloc(readl);
    *type = 4;
    dskbr_(&lun, *array, &readl, &istat);
    if (filec_debug)
      printf("Read Completion status : %d\n", istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    lflag = (1 == 1);
    dskbwr_(&lun, &lflag);
    if (bo != getbo()) {
      if (filec_debug)
        printf("Swapping bytes\n");
      swpbyt(0, readl, *array);
    }
  } else if (strcmp(s, "long") == 0 || strcmp(s, "long_integer") == 0 ||
             strcmp(s, "signed_long") == 0) {
    if (filec_debug)
      printf("Reading long image\n");
    readl = nelm * sizeof(int);
    if (filec_debug) {
      printf("Reading signed long image\n");
      printf("Allocating %d bytes\n", readl);
    }
    *array = malloc(readl);
    *type = 5;
    dskbr_(&lun, *array, &readl, &istat);
    if (filec_debug)
      printf("Read Completion status : %d\n", istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    lflag = (1 == 1);
    dskbwr_(&lun, &lflag);
    if (bo != getbo()) {
      if (filec_debug)
        printf("Swapping bytes\n");
      swpbyt(1, readl, *array);
    }
  } else if (strcmp(s, "float") == 0 || strcmp(s, "ieee_float") == 0) {
    if (filec_debug)
      printf("Reading float image\n");
    readl = nelm * sizeof(float);
    if (filec_debug) {
      printf("Reading float image\n");
      printf("Allocating %d bytes\n", readl);
    }
    *array = malloc(readl);
    *type = 7;
    dskbr_(&lun, *array, &readl, &istat);
    if (filec_debug)
      printf("Read Completion status : %d\n", istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    lflag = (1 == 1);
    dskbwr_(&lun, &lflag);
    if (bo != getbo()) {
      if (filec_debug)
        printf("Swapping bytes\n");
      swpbyt(1, readl, *array);
    }
  } else if (strcmp(s, "complex") == 0 || strcmp(s, "ieee_complex") == 0) {
    if (filec_debug)
      printf("Reading complex image\n");
    readl = nelm * 2 * sizeof(float);
    if (filec_debug) {
      printf("Reading complex image\n");
      printf("Allocating %d bytes\n", readl);
    }
    *array = malloc(readl);
    *type = 9;
    dskbr_(&lun, *array, &readl, &istat);
    if (filec_debug)
      printf("Read Completion status : %d\n", istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    lflag = (1 == 1);
    dskbwr_(&lun, &lflag);
    if (bo != getbo()) {
      if (filec_debug)
        printf("Swapping bytes\n");
      swpbyt(1, readl, *array);
    }
  } else if (strcmp(s, "swap_rlmsb") == 0) {
    unsigned char lsb[10 * 1024], msb[10 * 1024];
    unsigned char *lp, *mp, *alp, *amp;
    int lstart = 0, mstart = 0;
    int llen, n, val;
    int is1 = axis[0], is2 = axis[1];
    if (filec_debug)
      printf("Reading compressed image\n");
    if (dim != 2)
      goto close;
    readl = nelm * sizeof(unsigned short);
    *array = malloc(readl);
    bo = getbo();
    if (bo == 0) {
      lstart = 0;
      mstart = 1;
    } else if (bo == 1) {
      lstart = 1;
      mstart = 0;
    }
    llen = 2;
    dskbr_(&lun, (char *)lsb, &llen, &istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    llen = (int)lsb[llen - 2] * 256 + lsb[llen - 1];
    for (j = 0; j < (is2 - 1); j++) {
      if (filec_debug)
        printf("Reading %d bytes\n", llen);
      dskbr_(&lun, (char *)lsb, &llen, &istat);
      if (istat != 0) {
        istat = -2;
        goto close;
      }
      if (filec_debug)
        printf("Uncompressing %d bytes\n", llen - (is1)-2);
      for (lp = lsb + (is1), mp = msb; lp < lsb + llen - 2;) {
        n = *lp++;
        val = *lp++;
        if (filec_debug && 0)
          printf("Line %d, n %d, val %d\n", j, n, val);
        for (i = 0; i < n; i++)
          *mp++ = val;
      }
      if (filec_debug)
        printf("Restored %d bytes in MSB\n", mp - msb);
      alp = (unsigned char *)*array + 2 * j * is1 + lstart;
      amp = (unsigned char *)*array + 2 * j * is1 + mstart;
      for (lp = lsb, mp = msb; lp < lsb + (is1); alp += 2, amp += 2) {
        *alp = *lp++;
        *amp = *mp++;
      }
      if (filec_debug) {
        printf("Done line %d\n", j);
        printf("=================================\n");
      }
      llen = (int)lsb[llen - 2] * 256 + lsb[llen - 1];
    }
    llen -= 2;
    dskbr_(&lun, (char *)lsb, &llen, &istat);
    if (istat != 0) {
      istat = -2;
      goto close;
    }
    for (lp = lsb + (is1), mp = msb; lp < lsb + llen;) {
      n = *lp++;
      val = *lp++;
      if (filec_debug && 0)
        printf("Line %d, n %d, val %d\n", j, n, val);
      for (i = 0; i < n; i++)
        *mp++ = val;
    }
    if (filec_debug)
      printf("Restored %d bytes in MSB\n", mp - msb);
    alp = (unsigned char *)*array + 2 * j * is1 + lstart;
    amp = (unsigned char *)*array + 2 * j * is1 + mstart;
    for (lp = lsb, mp = msb; lp < lsb + (is1); alp += 2, amp += 2) {
      *alp = *lp++;
      *amp = *mp++;
    }
    if (filec_debug) {
      printf("Done line %d\n", j);
      printf("===================================\n");
    }
    puthd("TYPE", "unsigned_short", *head);
    *type = 4;
  } else {
    if (filec_debug)
      printf("Unsupported Filetype\n");
    istat = -4;
    goto close;
  }
close:
  if (filec_debug)
    printf("Done reading file\n");
  if (istat) {
    dskbcr_(&lun, &i);
    if (*head != 0)
      free(*head);
    if (*array != 0)
      free(*array);
  } else
    dskbcr_(&lun, &istat);
  if (filec_debug)
    printf("RDSMV completion status %d\n", istat);
  return istat;
}


x86 assembly (clang, -O0):
<rdsmv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x51b0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x1,-0x104(%rbp)
mov    $0x0,%al
call   1040 <filec_getdebug@plt>
mov    %eax,-0x11c(%rbp)
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x10(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     12af <rdsmv+0x7f>
mov    -0x10(%rbp),%rsi
lea    0x1d58(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x10(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x44(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1060 <dskbor_@plt>
cmpl   $0x0,-0x4c(%rbp)
je     1301 <rdsmv+0xd1>
cmpl   $0x0,-0x11c(%rbp)
je     12f5 <rdsmv+0xc5>
mov    -0x10(%rbp),%rsi
mov    -0x4c(%rbp),%edx
lea    0x1d24(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0xfffffffd,-0x4(%rbp)
jmp    29fa <rdsmv+0x17ca>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
movl   $0x200,-0x3c(%rbp)
mov    $0x200,%edi
call   10f0 <malloc@plt>
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   10b0 <memset@plt>
cmpl   $0x0,-0x11c(%rbp)
je     1366 <rdsmv+0x136>
lea    0x1cd4(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x118(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     13a1 <rdsmv+0x171>
mov    -0x4c(%rbp),%esi
lea    0x1ca9(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     13b7 <rdsmv+0x187>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
mov    -0x118(%rbp),%rsi
lea    -0x48(%rbp),%rdi
mov    $0x0,%al
call   1120 <gethdl@plt>
mov    %eax,-0x4c(%rbp)
cmp    $0x0,%eax
jge    13e1 <rdsmv+0x1b1>
movl   $0xfffffffc,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
cmpl   $0x0,-0x11c(%rbp)
je     13ff <rdsmv+0x1cf>
mov    -0x48(%rbp),%esi
lea    0x1c68(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%eax
mov    $0x400,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
add    $0x1,%ecx
shl    $0xa,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movslq (%rax),%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x20(%rbp),%rax
movslq (%rax),%rdx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x118(%rbp),%rsi
mov    $0x200,%edx
call   10d0 <memcpy@plt>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%eax
sub    $0x200,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jle    14bb <rdsmv+0x28b>
mov    -0x18(%rbp),%rax
mov    (%rax),%rsi
add    $0x200,%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x4c(%rbp)
je     14b6 <rdsmv+0x286>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
jmp    14bb <rdsmv+0x28b>
movl   $0x0,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
lea    -0xb0(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    (%rax),%rdx
lea    0x1b7b(%rip),%rdi
mov    $0x0,%al
call   1110 <gethd@plt>
movsbl -0xb0(%rbp),%eax
cmp    $0x0,%eax
je     1532 <rdsmv+0x302>
lea    -0xb0(%rbp),%rdi
lea    0x1b93(%rip),%rsi
lea    -0x54(%rbp),%rdx
mov    $0x0,%al
call   1100 <sscanf@plt>
cmp    $0x1,%eax
je     1552 <rdsmv+0x322>
cmpl   $0x0,-0x11c(%rbp)
je     154d <rdsmv+0x31d>
lea    0x1b32(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    2954 <rdsmv+0x1724>
cmpl   $0x0,-0x11c(%rbp)
je     1570 <rdsmv+0x340>
mov    -0x54(%rbp),%esi
lea    0x1b29(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x54(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x10c(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1657 <rdsmv+0x427>
lea    -0x100(%rbp),%rdi
mov    -0x40(%rbp),%edx
add    $0x1,%edx
lea    0x1b03(%rip),%rsi
mov    $0x0,%al
call   1150 <sprintf@plt>
lea    -0x100(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    (%rax),%rdx
mov    $0x0,%al
call   1110 <gethd@plt>
movsbl -0xb0(%rbp),%eax
cmp    $0x0,%eax
je     160a <rdsmv+0x3da>
lea    -0xb0(%rbp),%rdi
mov    -0x38(%rbp),%rdx
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0x1ab7(%rip),%rsi
mov    $0x0,%al
call   1100 <sscanf@plt>
cmp    $0x1,%eax
je     1631 <rdsmv+0x401>
cmpl   $0x0,-0x11c(%rbp)
je     162c <rdsmv+0x3fc>
lea    -0x100(%rbp),%rsi
lea    0x1a8f(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    2954 <rdsmv+0x1724>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x10c(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    158a <rdsmv+0x35a>
lea    -0xb0(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    (%rax),%rdx
lea    0x1a5a(%rip),%rdi
mov    $0x0,%al
call   1110 <gethd@plt>
cmpb   $0x0,-0xb0(%rbp)
je     16e6 <rdsmv+0x4b6>
lea    -0xb0(%rbp),%rdi
lea    0x1a43(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    16a8 <rdsmv+0x478>
movl   $0x0,-0x50(%rbp)
jmp    16e1 <rdsmv+0x4b1>
lea    -0xb0(%rbp),%rdi
lea    0x1a29(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    16d0 <rdsmv+0x4a0>
movl   $0x1,-0x50(%rbp)
jmp    16dc <rdsmv+0x4ac>
movl   $0xfffffffc,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
jmp    16e1 <rdsmv+0x4b1>
jmp    16ed <rdsmv+0x4bd>
movl   $0xffffffff,-0x50(%rbp)
lea    -0xb0(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    (%rax),%rdx
lea    0x19e8(%rip),%rdi
mov    $0x0,%al
call   1110 <gethd@plt>
cmpl   $0x0,-0x11c(%rbp)
je     17c8 <rdsmv+0x598>
lea    -0xb0(%rbp),%rsi
lea    0x19cb(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x54(%rbp),%esi
lea    0x19c5(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1776 <rdsmv+0x546>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x19a9(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1743 <rdsmv+0x513>
lea    0x197b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x10c(%rbp),%esi
lea    0x197e(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x50(%rbp)
je     17b5 <rdsmv+0x585>
lea    0x197f(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    17c3 <rdsmv+0x593>
lea    0x1985(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    17c8 <rdsmv+0x598>
lea    -0xb0(%rbp),%rdi
lea    0x1987(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1838 <rdsmv+0x608>
lea    -0xb0(%rbp),%rdi
lea    0x1974(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1838 <rdsmv+0x608>
lea    -0xb0(%rbp),%rdi
lea    0x195d(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1838 <rdsmv+0x608>
lea    -0xb0(%rbp),%rdi
lea    0x194a(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    1a0e <rdsmv+0x7de>
cmpl   $0x0,-0x11c(%rbp)
je     1853 <rdsmv+0x623>
lea    0x192d(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x10c(%rbp),%rax
shl    $0x0,%rax
mov    %eax,-0x3c(%rbp)
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,-0x128(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     189d <rdsmv+0x66d>
mov    -0x3c(%rbp),%esi
lea    0x1905(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x191b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x128(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     18d8 <rdsmv+0x6a8>
mov    -0x4c(%rbp),%esi
lea    0x18fd(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     18ee <rdsmv+0x6be>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     1939 <rdsmv+0x709>
movslq -0x10c(%rbp),%rax
shl    $0x1,%rax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%esi
lea    0x18be(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x10c(%rbp),%rdi
shl    $0x1,%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x138(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0x130(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     199a <rdsmv+0x76a>
mov    -0x10c(%rbp),%esi
lea    0x1882(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jge    19fd <rdsmv+0x7cd>
mov    -0x130(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x130(%rbp)
movzbl (%rax),%eax
mov    %ax,%cx
mov    -0x138(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x138(%rbp)
mov    %cx,(%rax)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    19a4 <rdsmv+0x774>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
jmp    294f <rdsmv+0x171f>
lea    -0xb0(%rbp),%rdi
lea    0x181d(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    1bd7 <rdsmv+0x9a7>
cmpl   $0x0,-0x11c(%rbp)
je     1a45 <rdsmv+0x815>
lea    0x17ff(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x10c(%rbp),%rax
shl    $0x0,%rax
shr    $0x3,%rax
mov    %eax,-0x3c(%rbp)
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,-0x148(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     1a82 <rdsmv+0x852>
lea    0x17c2(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x148(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     1abd <rdsmv+0x88d>
mov    -0x4c(%rbp),%esi
lea    0x158d(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     1ad3 <rdsmv+0x8a3>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
movslq -0x10c(%rbp),%rdi
shl    $0x1,%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x158(%rbp)
mov    -0x148(%rbp),%rax
mov    %rax,-0x150(%rbp)
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jge    1bc6 <rdsmv+0x996>
movl   $0x0,-0x44(%rbp)
cmpl   $0x8,-0x44(%rbp)
jge    1ba0 <rdsmv+0x970>
mov    -0x150(%rbp),%rax
movzbl (%rax),%eax
mov    -0x44(%rbp),%ecx
mov    $0x2,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
mov    %ax,%cx
mov    -0x158(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x158(%rbp)
mov    %cx,(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b55 <rdsmv+0x925>
mov    -0x150(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x150(%rbp)
mov    -0x13c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x13c(%rbp)
jmp    1b3c <rdsmv+0x90c>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
jmp    294a <rdsmv+0x171a>
lea    -0xb0(%rbp),%rdi
lea    0x166b(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1c0f <rdsmv+0x9df>
lea    -0xb0(%rbp),%rdi
lea    0x1653(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    1d44 <rdsmv+0xb14>
cmpl   $0x0,-0x11c(%rbp)
je     1c2a <rdsmv+0x9fa>
lea    0x1640(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x10c(%rbp),%rax
shl    $0x1,%rax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     1c64 <rdsmv+0xa34>
lea    0x1617(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0x1624(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     1cbc <rdsmv+0xa8c>
mov    -0x4c(%rbp),%esi
lea    0x138e(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     1cd2 <rdsmv+0xaa2>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
mov    -0x50(%rbp),%eax
mov    %eax,-0x51a0(%rbp)
mov    $0x0,%al
call   1140 <getbo@plt>
mov    %eax,%ecx
mov    -0x51a0(%rbp),%eax
cmp    %ecx,%eax
je     1d3f <rdsmv+0xb0f>
cmpl   $0x0,-0x11c(%rbp)
je     1d2c <rdsmv+0xafc>
lea    0x1571(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%rdx
xor    %edi,%edi
mov    $0x0,%al
call   10a0 <swpbyt@plt>
jmp    2945 <rdsmv+0x1715>
lea    -0xb0(%rbp),%rdi
lea    0x1568(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1d98 <rdsmv+0xb68>
lea    -0xb0(%rbp),%rdi
lea    0x1538(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1d98 <rdsmv+0xb68>
lea    -0xb0(%rbp),%rdi
lea    0x1529(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    1ed0 <rdsmv+0xca0>
cmpl   $0x0,-0x11c(%rbp)
je     1db3 <rdsmv+0xb83>
lea    0x1513(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x10c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     1ded <rdsmv+0xbbd>
lea    0x14fe(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0x149b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
movl   $0x5,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     1e45 <rdsmv+0xc15>
mov    -0x4c(%rbp),%esi
lea    0x1205(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     1e5b <rdsmv+0xc2b>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
mov    -0x50(%rbp),%eax
mov    %eax,-0x51a4(%rbp)
mov    $0x0,%al
call   1140 <getbo@plt>
mov    %eax,%ecx
mov    -0x51a4(%rbp),%eax
cmp    %ecx,%eax
je     1ecb <rdsmv+0xc9b>
cmpl   $0x0,-0x11c(%rbp)
je     1eb5 <rdsmv+0xc85>
lea    0x13e8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%rdx
mov    $0x1,%edi
mov    $0x0,%al
call   10a0 <swpbyt@plt>
jmp    2940 <rdsmv+0x1710>
lea    -0xb0(%rbp),%rdi
lea    0x1415(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     1f08 <rdsmv+0xcd8>
lea    -0xb0(%rbp),%rdi
lea    0x13f4(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    2040 <rdsmv+0xe10>
cmpl   $0x0,-0x11c(%rbp)
je     1f23 <rdsmv+0xcf3>
lea    0x13dd(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x10c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     1f5d <rdsmv+0xd2d>
lea    0x13b4(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0x132b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
movl   $0x7,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     1fb5 <rdsmv+0xd85>
mov    -0x4c(%rbp),%esi
lea    0x1095(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     1fcb <rdsmv+0xd9b>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
mov    -0x50(%rbp),%eax
mov    %eax,-0x51a8(%rbp)
mov    $0x0,%al
call   1140 <getbo@plt>
mov    %eax,%ecx
mov    -0x51a8(%rbp),%eax
cmp    %ecx,%eax
je     203b <rdsmv+0xe0b>
cmpl   $0x0,-0x11c(%rbp)
je     2025 <rdsmv+0xdf5>
lea    0x1278(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%rdx
mov    $0x1,%edi
mov    $0x0,%al
call   10a0 <swpbyt@plt>
jmp    293b <rdsmv+0x170b>
lea    -0xb0(%rbp),%rdi
lea    0x12c5(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     2078 <rdsmv+0xe48>
lea    -0xb0(%rbp),%rdi
lea    0x12a4(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    21b4 <rdsmv+0xf84>
cmpl   $0x0,-0x11c(%rbp)
je     2093 <rdsmv+0xe63>
lea    0x128f(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x10c(%rbp),%eax
shl    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     20d1 <rdsmv+0xea1>
lea    0x1262(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0x11b7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
movl   $0x9,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x3c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     2129 <rdsmv+0xef9>
mov    -0x4c(%rbp),%esi
lea    0xf21(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     213f <rdsmv+0xf0f>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
movl   $0x1,-0x108(%rbp)
lea    -0x104(%rbp),%rdi
lea    -0x108(%rbp),%rsi
mov    $0x0,%al
call   10e0 <dskbwr_@plt>
mov    -0x50(%rbp),%eax
mov    %eax,-0x51ac(%rbp)
mov    $0x0,%al
call   1140 <getbo@plt>
mov    %eax,%ecx
mov    -0x51ac(%rbp),%eax
cmp    %ecx,%eax
je     21af <rdsmv+0xf7f>
cmpl   $0x0,-0x11c(%rbp)
je     2199 <rdsmv+0xf69>
lea    0x1104(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x3c(%rbp),%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%rdx
mov    $0x1,%edi
mov    $0x0,%al
call   10a0 <swpbyt@plt>
jmp    2936 <rdsmv+0x1706>
lea    -0xb0(%rbp),%rdi
lea    0x1170(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    290a <rdsmv+0x16da>
movl   $0x0,-0x5184(%rbp)
movl   $0x0,-0x5188(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5198(%rbp)
mov    -0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x519c(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     2218 <rdsmv+0xfe8>
lea    0x112c(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x2,-0x54(%rbp)
je     2227 <rdsmv+0xff7>
jmp    2954 <rdsmv+0x1724>
movslq -0x10c(%rbp),%rax
shl    $0x1,%rax
mov    %eax,-0x3c(%rbp)
movslq -0x3c(%rbp),%rdi
call   10f0 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    $0x0,%al
call   1140 <getbo@plt>
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
jne    2275 <rdsmv+0x1045>
movl   $0x0,-0x5184(%rbp)
movl   $0x1,-0x5188(%rbp)
jmp    2298 <rdsmv+0x1068>
cmpl   $0x1,-0x50(%rbp)
jne    2293 <rdsmv+0x1063>
movl   $0x1,-0x5184(%rbp)
movl   $0x0,-0x5188(%rbp)
jmp    2298 <rdsmv+0x1068>
movl   $0x2,-0x518c(%rbp)
lea    -0x2960(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x518c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x4c(%rbp)
je     22d8 <rdsmv+0x10a8>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
mov    -0x518c(%rbp),%eax
sub    $0x2,%eax
cltq
movzbl -0x2960(%rbp,%rax,1),%eax
ff
shl    $0x8,%eax
mov    -0x518c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x2960(%rbp,%rcx,1),%ecx
ff
add    %ecx,%eax
mov    %eax,-0x518c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x519c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2642 <rdsmv+0x1412>
cmpl   $0x0,-0x11c(%rbp)
je     2346 <rdsmv+0x1116>
mov    -0x518c(%rbp),%esi
lea    0x1018(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    -0x2960(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x518c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x4c(%rbp)
je     237c <rdsmv+0x114c>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
cmpl   $0x0,-0x11c(%rbp)
je     23a6 <rdsmv+0x1176>
mov    -0x518c(%rbp),%esi
sub    -0x5198(%rbp),%esi
sub    $0x2,%esi
lea    0xfca(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    -0x2960(%rbp),%rax
movslq -0x5198(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x5168(%rbp)
lea    -0x5160(%rbp),%rax
mov    %rax,-0x5170(%rbp)
mov    -0x5168(%rbp),%rax
lea    -0x2960(%rbp),%rcx
movslq -0x518c(%rbp),%rdx
add    %rdx,%rcx
add    $0xfffffffffffffffe,%rcx
cmp    %rcx,%rax
jae    24ae <rdsmv+0x127e>
mov    -0x5168(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5168(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x5190(%rbp)
mov    -0x5168(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5168(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x5194(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     2466 <rdsmv+0x1236>
xor    %eax,%eax
test   $0x1,%al
jne    2449 <rdsmv+0x1219>
jmp    2466 <rdsmv+0x1236>
mov    -0x44(%rbp),%esi
mov    -0x5190(%rbp),%edx
mov    -0x5194(%rbp),%ecx
lea    0xf22(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x5190(%rbp),%eax
jge    24a9 <rdsmv+0x1279>
mov    -0x5194(%rbp),%eax
mov    %al,%cl
mov    -0x5170(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x5170(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    246d <rdsmv+0x123d>
jmp    23cc <rdsmv+0x119c>
cmpl   $0x0,-0x11c(%rbp)
je     24da <rdsmv+0x12aa>
mov    -0x5170(%rbp),%rsi
lea    -0x5160(%rbp),%rax
sub    %rax,%rsi
lea    0xec5(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x5198(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x5184(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x5178(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x5198(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x5188(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x5180(%rbp)
lea    -0x2960(%rbp),%rax
mov    %rax,-0x5168(%rbp)
lea    -0x5160(%rbp),%rax
mov    %rax,-0x5170(%rbp)
mov    -0x5168(%rbp),%rax
lea    -0x2960(%rbp),%rcx
movslq -0x5198(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    25d6 <rdsmv+0x13a6>
mov    -0x5168(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5168(%rbp)
mov    (%rax),%cl
mov    -0x5178(%rbp),%rax
mov    %cl,(%rax)
mov    -0x5170(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5170(%rbp)
mov    (%rax),%cl
mov    -0x5180(%rbp),%rax
mov    %cl,(%rax)
mov    -0x5178(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x5178(%rbp)
mov    -0x5180(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x5180(%rbp)
jmp    254c <rdsmv+0x131c>
cmpl   $0x0,-0x11c(%rbp)
je     2602 <rdsmv+0x13d2>
mov    -0x44(%rbp),%esi
lea    0xdc5(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0xdc7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x518c(%rbp),%eax
sub    $0x2,%eax
cltq
movzbl -0x2960(%rbp,%rax,1),%eax
ff
shl    $0x8,%eax
mov    -0x518c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x2960(%rbp,%rcx,1),%ecx
ff
add    %ecx,%eax
mov    %eax,-0x518c(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2311 <rdsmv+0x10e1>
mov    -0x518c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x518c(%rbp)
lea    -0x2960(%rbp),%rsi
lea    -0x104(%rbp),%rdi
lea    -0x518c(%rbp),%rdx
lea    -0x4c(%rbp),%rcx
mov    $0x0,%al
call   1130 <dskbr_@plt>
cmpl   $0x0,-0x4c(%rbp)
je     2687 <rdsmv+0x1457>
movl   $0xfffffffe,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
lea    -0x2960(%rbp),%rax
movslq -0x5198(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x5168(%rbp)
lea    -0x5160(%rbp),%rax
mov    %rax,-0x5170(%rbp)
mov    -0x5168(%rbp),%rax
lea    -0x2960(%rbp),%rcx
movslq -0x518c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    278b <rdsmv+0x155b>
mov    -0x5168(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5168(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x5190(%rbp)
mov    -0x5168(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5168(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x5194(%rbp)
cmpl   $0x0,-0x11c(%rbp)
je     2743 <rdsmv+0x1513>
xor    %eax,%eax
test   $0x1,%al
jne    2726 <rdsmv+0x14f6>
jmp    2743 <rdsmv+0x1513>
mov    -0x44(%rbp),%esi
mov    -0x5190(%rbp),%edx
mov    -0x5194(%rbp),%ecx
lea    0xc45(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x5190(%rbp),%eax
jge    2786 <rdsmv+0x1556>
mov    -0x5194(%rbp),%eax
mov    %al,%cl
mov    -0x5170(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x5170(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    274a <rdsmv+0x151a>
jmp    26ad <rdsmv+0x147d>
cmpl   $0x0,-0x11c(%rbp)
je     27b7 <rdsmv+0x1587>
mov    -0x5170(%rbp),%rsi
lea    -0x5160(%rbp),%rax
sub    %rax,%rsi
lea    0xbe8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x5198(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x5184(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x5178(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x5198(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x5188(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x5180(%rbp)
lea    -0x2960(%rbp),%rax
mov    %rax,-0x5168(%rbp)
lea    -0x5160(%rbp),%rax
mov    %rax,-0x5170(%rbp)
mov    -0x5168(%rbp),%rax
lea    -0x2960(%rbp),%rcx
movslq -0x5198(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    28b3 <rdsmv+0x1683>
mov    -0x5168(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5168(%rbp)
mov    (%rax),%cl
mov    -0x5178(%rbp),%rax
mov    %cl,(%rax)
mov    -0x5170(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5170(%rbp)
mov    (%rax),%cl
mov    -0x5180(%rbp),%rax
mov    %cl,(%rax)
mov    -0x5178(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x5178(%rbp)
mov    -0x5180(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x5180(%rbp)
jmp    2829 <rdsmv+0x15f9>
cmpl   $0x0,-0x11c(%rbp)
je     28df <rdsmv+0x16af>
mov    -0x44(%rbp),%esi
lea    0xae8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0xae8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdx
lea    0x7fd(%rip),%rdi
lea    0x960(%rip),%rsi
mov    $0x0,%al
call   1090 <puthd@plt>
mov    0x10(%rbp),%rax
movl   $0x4,(%rax)
jmp    2931 <rdsmv+0x1701>
cmpl   $0x0,-0x11c(%rbp)
je     2925 <rdsmv+0x16f5>
lea    0xac7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0xfffffffc,-0x4c(%rbp)
jmp    2954 <rdsmv+0x1724>
jmp    2936 <rdsmv+0x1706>
jmp    293b <rdsmv+0x170b>
jmp    2940 <rdsmv+0x1710>
jmp    2945 <rdsmv+0x1715>
jmp    294a <rdsmv+0x171a>
jmp    294f <rdsmv+0x171f>
jmp    2954 <rdsmv+0x1724>
cmpl   $0x0,-0x11c(%rbp)
je     296f <rdsmv+0x173f>
lea    0xa93(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpl   $0x0,-0x4c(%rbp)
je     29c4 <rdsmv+0x1794>
lea    -0x104(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x0,%al
call   1070 <dskbcr_@plt>
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
je     29a5 <rdsmv+0x1775>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rax
cmpq   $0x0,(%rax)
je     29bf <rdsmv+0x178f>
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
jmp    29d6 <rdsmv+0x17a6>
lea    -0x104(%rbp),%rdi
lea    -0x4c(%rbp),%rsi
mov    $0x0,%al
call   1070 <dskbcr_@plt>
cmpl   $0x0,-0x11c(%rbp)
je     29f4 <rdsmv+0x17c4>
mov    -0x4c(%rbp),%esi
lea    0xa21(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x51b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rdsmv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5108,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,%r15
mov    %rcx,%r14
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
movl   $0x1,0xc(%rsp)
xor    %eax,%eax
call   1050 <filec_getdebug@plt>
mov    %eax,%r12d
movq   $0x0,(%rbx)
movq   $0x0,(%r14)
mov    %rbp,%rdi
call   1070 <strlen@plt>
mov    %eax,0x2c(%rsp)
test   %r12d,%r12d
je     12f0 <rdsmv+0xa0>
lea    0x1dd3(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0xc(%rsp),%rdi
lea    0x2c(%rsp),%rdx
mov    %rsp,%rcx
mov    %rbp,%rsi
xor    %eax,%eax
call   1080 <dskbor_@plt>
mov    (%rsp),%edx
test   %edx,%edx
je     1316 <rdsmv+0xc6>
lea    0x1db6(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    $0xfffffffd,%eax
jmp    1429 <rdsmv+0x1d9>
lea    0xc(%rsp),%rdi
lea    0x2c(%rsp),%rdx
mov    %rsp,%rcx
mov    %rbp,%rsi
xor    %eax,%eax
call   1080 <dskbor_@plt>
mov    $0xfffffffd,%eax
cmpl   $0x0,(%rsp)
jne    1429 <rdsmv+0x1d9>
mov    %rbx,0x20(%rsp)
mov    %r14,0x10(%rsp)
movl   $0x1,0x18(%rsp)
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
movl   $0x200,0x4(%rsp)
mov    $0x1,%edi
mov    $0x200,%esi
call   10e0 <calloc@plt>
mov    %rax,%r14
test   %r12d,%r12d
je     1397 <rdsmv+0x147>
lea    0x20f3(%rip),%rdi
call   1060 <puts@plt>
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %r14,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
mov    (%rsp),%esi
lea    0x1d2e(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
cmpl   $0x0,(%rsp)
jne    13b8 <rdsmv+0x168>
jmp    143b <rdsmv+0x1eb>
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %r14,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
je     143b <rdsmv+0x1eb>
movl   $0xfffffffe,(%rsp)
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%rbx
test   %r12d,%r12d
je     13da <rdsmv+0x18a>
lea    0x1f09(%rip),%rdi
call   1060 <puts@plt>
cmpl   $0x0,(%rsp)
je     1524 <rdsmv+0x2d4>
lea    0xc(%rsp),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1090 <dskbcr_@plt>
mov    (%rbx),%rdi
test   %rdi,%rdi
je     1402 <rdsmv+0x1b2>
call   1030 <free@plt>
mov    0x0(%rbp),%rdi
test   %rdi,%rdi
je     1410 <rdsmv+0x1c0>
call   1030 <free@plt>
test   %r12d,%r12d
je     1426 <rdsmv+0x1d6>
mov    (%rsp),%esi
lea    0x1ea3(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    (%rsp),%eax
add    $0x5108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x4c(%rsp),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1140 <gethdl@plt>
mov    %eax,(%rsp)
test   %eax,%eax
js     16d6 <rdsmv+0x486>
mov    %r12d,0x8(%rsp)
test   %r12d,%r12d
je     1471 <rdsmv+0x221>
mov    0x4c(%rsp),%esi
lea    0x1c66(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x4c(%rsp),%r12d
lea    0x3ff(%r12),%eax
test   %r12d,%r12d
cmovns %r12d,%eax
and    $0xfffffc00,%eax
add    $0x400,%eax
mov    %eax,0x0(%r13)
movslq %eax,%rbx
mov    %rbx,%rdi
call   1110 <malloc@plt>
mov    %rax,%rbp
mov    0x20(%rsp),%rax
mov    %rbp,(%rax)
lea    -0x200(%rbx),%rax
xor    %edx,%edx
test   %ebx,%ebx
cmovne %rax,%rdx
lea    0x200(%rbp),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
call   10d0 <memset@plt>
mov    $0x200,%edx
mov    %rbp,%rdi
mov    %r14,%rsi
call   10f0 <memcpy@plt>
mov    %r14,%rdi
call   1030 <free@plt>
lea    -0x200(%r12),%eax
ff
mov    %eax,0x4(%rsp)
cmp    $0x201,%r12d
jl     1541 <rdsmv+0x2f1>
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %rbx,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
je     1541 <rdsmv+0x2f1>
movl   $0xfffffffe,(%rsp)
mov    0x8(%rsp),%r12d
jmp    13bf <rdsmv+0x16f>
lea    0xc(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1090 <dskbcr_@plt>
test   %r12d,%r12d
jne    1415 <rdsmv+0x1c5>
jmp    1426 <rdsmv+0x1d6>
movl   $0x0,0x18(%rsp)
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
movl   $0x0,(%r15)
mov    0x20(%rsp),%rbx
mov    (%rbx),%rdx
lea    0x1b74(%rip),%rdi
lea    0x60(%rsp),%rsi
xor    %eax,%eax
call   1130 <gethd@plt>
cmpb   $0x0,0x60(%rsp)
mov    0x8(%rsp),%r12d
je     16e2 <rdsmv+0x492>
lea    0x1b74(%rip),%rsi
lea    0x60(%rsp),%rdi
lea    0x34(%rsp),%rdx
xor    %eax,%eax
call   1120 <sscanf@plt>
cmp    $0x1,%eax
jne    16e2 <rdsmv+0x492>
test   %r12d,%r12d
je     15c4 <rdsmv+0x374>
mov    0x34(%rsp),%esi
lea    0x1b2b(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x34(%rsp),%eax
mov    %eax,(%r15)
movl   $0x0,0x30(%rsp)
test   %eax,%eax
mov    0x38(%rsp),%r12
mov    $0x1,%r13d
jle    165f <rdsmv+0x40f>
lea    0xb0(%rsp),%rbp
lea    0x60(%rsp),%rbx
lea    0x1b11(%rip),%r14
xor    %r15d,%r15d
add    $0x1,%r15d
mov    %rbp,%rdi
lea    0x1afc(%rip),%rsi
mov    %r15d,%edx
xor    %eax,%eax
call   1170 <sprintf@plt>
mov    0x20(%rsp),%rax
mov    (%rax),%rdx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1130 <gethd@plt>
cmpb   $0x0,0x60(%rsp)
je     1701 <rdsmv+0x4b1>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1120 <sscanf@plt>
cmp    $0x1,%eax
jne    1701 <rdsmv+0x4b1>
imul   (%r12),%r13d
mov    %r15d,0x30(%rsp)
add    $0x4,%r12
cmp    0x34(%rsp),%r15d
jl     15f9 <rdsmv+0x3a9>
mov    0x20(%rsp),%rax
mov    (%rax),%rdx
lea    0x1aae(%rip),%rdi
xor    %ebp,%ebp
lea    0x60(%rsp),%rsi
xor    %eax,%eax
call   1130 <gethd@plt>
lea    0x1d9e(%rip),%r14
cmpb   $0x0,0x60(%rsp)
je     1734 <rdsmv+0x4e4>
movabs $0x655f656c7474696c,%rcx
65 5f 65
xor    0x60(%rsp),%rcx
movabs $0x6e6169646e655f,%rax
mov    0x66(%rsp),%rdx
xor    %rax,%rdx
or     %rcx,%rdx
mov    0x8(%rsp),%r12d
je     1740 <rdsmv+0x4f0>
movabs $0x69646e655f676962,%rcx
6e 64 69
xor    0x60(%rsp),%rcx
xor    0x63(%rsp),%rax
or     %rcx,%rax
je     1749 <rdsmv+0x4f9>
movl   $0xfffffffc,(%rsp)
jmp    13bf <rdsmv+0x16f>
test   %r12d,%r12d
mov    0x10(%rsp),%rbp
je     13da <rdsmv+0x18a>
lea    0x1d42(%rip),%rdi
call   1060 <puts@plt>
jmp    13ce <rdsmv+0x17e>
mov    0x8(%rsp),%r12d
test   %r12d,%r12d
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%rbx
je     13da <rdsmv+0x18a>
lea    0x19ea(%rip),%rdi
lea    0xb0(%rsp),%rsi
xor    %eax,%eax
call   10a0 <printf@plt>
jmp    13ce <rdsmv+0x17e>
mov    $0xffffffff,%ebp
mov    0x8(%rsp),%r12d
jmp    174e <rdsmv+0x4fe>
lea    0x1cbf(%rip),%r14
jmp    174e <rdsmv+0x4fe>
mov    $0x1,%ebp
mov    0x20(%rsp),%rax
mov    (%rax),%rdx
lea    0x19ca(%rip),%rdi
lea    0x60(%rsp),%rsi
xor    %eax,%eax
call   1130 <gethd@plt>
test   %r12d,%r12d
je     17fb <rdsmv+0x5ab>
mov    %ebp,0x40(%rsp)
lea    0x19af(%rip),%rdi
lea    0x60(%rsp),%rsi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x34(%rsp),%esi
lea    0x19a3(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
movl   $0x0,0x30(%rsp)
cmpl   $0x0,0x34(%rsp)
mov    0x38(%rsp),%r15
jle    17d4 <rdsmv+0x584>
lea    0x1991(%rip),%rbp
xor    %ebx,%ebx
mov    (%r15,%rbx,4),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
add    $0x1,%rbx
mov    %ebx,0x30(%rsp)
cmp    0x34(%rsp),%ebx
jl     17b8 <rdsmv+0x568>
mov    $0xa,%edi
call   1040 <putchar@plt>
lea    0x1967(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    %r14,%rdi
call   1060 <puts@plt>
mov    0x40(%rsp),%ebp
mov    0x5140(%rsp),%r14
movabs $0x64656e6769736e75,%rax
6e 65 64
mov    0x60(%rsp),%rcx
xor    %rax,%rcx
movabs $0x657479625f6465,%rdx
xor    0x66(%rsp),%rdx
or     %rcx,%rdx
je     18fd <rdsmv+0x6ad>
mov    $0x65747962,%ecx
xor    0x60(%rsp),%ecx
movzbl 0x64(%rsp),%edx
or     %ecx,%edx
je     18fd <rdsmv+0x6ad>
mov    0x60(%rsp),%rcx
xor    %rax,%rcx
movabs $0x726168635f6465,%rdx
xor    0x66(%rsp),%rdx
or     %rcx,%rdx
je     18fd <rdsmv+0x6ad>
mov    $0x72616863,%ecx
xor    0x60(%rsp),%ecx
movzbl 0x64(%rsp),%edx
or     %ecx,%edx
je     18fd <rdsmv+0x6ad>
mov    0x60(%rsp),%ecx
cmp    $0x64616d,%ecx
je     1be8 <rdsmv+0x998>
cmp    $0x746962,%ecx
jne    1ab3 <rdsmv+0x863>
test   %r12d,%r12d
je     18a6 <rdsmv+0x656>
lea    0x1b24(%rip),%rdi
call   1060 <puts@plt>
mov    %r13d,%eax
sar    $0x3,%eax
mov    %eax,0x4(%rsp)
movslq %eax,%rdi
call   1110 <malloc@plt>
mov    %rax,%r15
test   %r12d,%r12d
je     1d82 <rdsmv+0xb32>
lea    0x1afa(%rip),%rdi
call   1060 <puts@plt>
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %r15,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
mov    (%rsp),%esi
lea    0x17c2(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
jmp    1d99 <rdsmv+0xb49>
test   %r12d,%r12d
je     1968 <rdsmv+0x718>
lea    0x1aea(%rip),%rdi
call   1060 <puts@plt>
movslq %r13d,%rbx
mov    %r13d,0x4(%rsp)
mov    %rbx,%rdi
call   1110 <malloc@plt>
mov    %rax,%r12
lea    0x1859(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x1a9e(%rip),%rdi
call   1060 <puts@plt>
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %r12,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
mov    (%rsp),%esi
lea    0x1846(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
jmp    1992 <rdsmv+0x742>
movslq %r13d,%rbx
mov    %r13d,0x4(%rsp)
mov    %rbx,%rdi
call   1110 <malloc@plt>
mov    %rax,%r12
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
jne    1513 <rdsmv+0x2c3>
movl   $0x1,0x18(%rsp)
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
cmpl   $0x0,0x8(%rsp)
je     19d3 <rdsmv+0x783>
lea    0x0(%r13,%r13,1),%esi
mov    %esi,0x4(%rsp)
lea    0x17fb(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
add    %rbx,%rbx
mov    %rbx,%rdi
call   1110 <malloc@plt>
mov    %rax,%r15
mov    0x10(%rsp),%rax
mov    %r15,(%rax)
movl   $0x4,(%r14)
cmpl   $0x0,0x8(%rsp)
je     1a08 <rdsmv+0x7b8>
lea    0x17ee(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
test   %r13d,%r13d
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%rbx
jle    1c7b <rdsmv+0xa2b>
lea    -0x1(%r13),%ecx
cmp    $0xf,%ecx
jae    1a2e <rdsmv+0x7de>
xor    %eax,%eax
mov    %r12,%rcx
jmp    1c64 <rdsmv+0xa14>
add    $0x1,%rcx
mov    %rcx,%rax
and    $0xfffffffffffffff0,%rax
lea    -0x10(%rax),%rdx
mov    %rdx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1c29 <rdsmv+0x9d9>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
pxor   %xmm0,%xmm0
movq   (%r12,%rdx,1),%xmm1
movq   0x8(%r12,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%r15,%rdx,2)
movdqu %xmm2,0x10(%r15,%rdx,2)
movq   0x10(%r12,%rdx,1),%xmm1
movq   0x18(%r12,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x20(%r15,%rdx,2)
movdqu %xmm2,0x30(%r15,%rdx,2)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1a5e <rdsmv+0x80e>
jmp    1c2b <rdsmv+0x9db>
xor    0x60(%rsp),%rax
movabs $0x74726f68735f64,%rcx
xor    0x67(%rsp),%rcx
or     %rax,%rcx
je     1be8 <rdsmv+0x998>
mov    $0x676e6f6c,%eax
xor    0x60(%rsp),%eax
movzbl 0x64(%rsp),%ecx
or     %eax,%ecx
je     1d3c <rdsmv+0xaec>
movabs $0x746e695f676e6f6c,%rax
69 6e 74
xor    0x60(%rsp),%rax
movabs $0x72656765746e69,%rcx
xor    0x65(%rsp),%rcx
or     %rax,%rcx
je     1d3c <rdsmv+0xaec>
movabs $0x6c5f64656e676973,%rax
64 5f 6c
xor    0x60(%rsp),%rax
mov    0x68(%rsp),%ecx
xor    $0x676e6f,%rcx
or     %rax,%rcx
je     1d3c <rdsmv+0xaec>
mov    $0x616f6c66,%eax
xor    0x60(%rsp),%eax
movzwl 0x64(%rsp),%ecx
xor    $0x74,%ecx
or     %eax,%ecx
je     216c <rdsmv+0xf1c>
movabs $0x6f6c665f65656569,%rax
66 6c 6f
xor    0x60(%rsp),%rax
movabs $0x74616f6c665f65,%rcx
xor    0x63(%rsp),%rcx
or     %rax,%rcx
je     216c <rdsmv+0xf1c>
movabs $0x78656c706d6f63,%rax
cmp    %rax,0x60(%rsp)
je     21ac <rdsmv+0xf5c>
movabs $0x6d6f635f65656569,%rcx
63 6f 6d
xor    0x60(%rsp),%rcx
xor    0x65(%rsp),%rax
or     %rcx,%rax
je     21ac <rdsmv+0xf5c>
movabs $0x6d6c725f70617773,%rax
72 6c 6d
xor    0x60(%rsp),%rax
movabs $0x62736d6c725f70,%rcx
xor    0x63(%rsp),%rcx
or     %rax,%rcx
je     22d2 <rdsmv+0x1082>
cmpl   $0x0,0x8(%rsp)
je     1bdc <rdsmv+0x98c>
lea    0x1719(%rip),%rdi
call   1060 <puts@plt>
movl   $0xfffffffc,(%rsp)
jmp    151a <rdsmv+0x2ca>
test   %r12d,%r12d
je     1c8d <rdsmv+0xa3d>
lea    0x17b0(%rip),%rbx
mov    %rbx,%rdi
call   1060 <puts@plt>
add    %r13d,%r13d
mov    %r13d,0x4(%rsp)
mov    %rbx,%rdi
call   1060 <puts@plt>
mov    0x4(%rsp),%esi
lea    0x1604(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x4(%rsp),%r13d
jmp    1c95 <rdsmv+0xa45>
xor    %edx,%edx
test   $0x1,%sil
je     1c57 <rdsmv+0xa07>
movq   (%r12,%rdx,1),%xmm0
movq   0x8(%r12,%rdx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%r15,%rdx,2)
movdqu %xmm1,0x10(%r15,%rdx,2)
cmp    %rax,%rcx
je     1c7b <rdsmv+0xa2b>
lea    (%r15,%rax,2),%r15
lea    (%r12,%rax,1),%rcx
sub    %eax,%r13d
xor    %eax,%eax
movzbl (%rcx,%rax,1),%edx
mov    %dx,(%r15,%rax,2)
add    $0x1,%rax
cmp    %eax,%r13d
jne    1c69 <rdsmv+0xa19>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%r12d
jmp    13c9 <rdsmv+0x179>
add    %r13d,%r13d
mov    %r13d,0x4(%rsp)
movslq %r13d,%rdi
call   1110 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movl   $0x4,(%r14)
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
test   %r12d,%r12d
je     1cd9 <rdsmv+0xa89>
mov    (%rsp),%esi
lea    0x13e1(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
cmpl   $0x0,(%rsp)
mov    0x20(%rsp),%rbx
jne    1e54 <rdsmv+0xc04>
movl   $0x1,0x18(%rsp)
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
xor    %eax,%eax
call   1160 <getbo@plt>
cmp    %eax,%ebp
mov    0x10(%rsp),%rbp
je     13c9 <rdsmv+0x179>
test   %r12d,%r12d
je     1d26 <rdsmv+0xad6>
lea    0x1678(%rip),%rdi
call   1060 <puts@plt>
mov    0x4(%rsp),%esi
mov    0x0(%rbp),%rdx
xor    %edi,%edi
xor    %eax,%eax
call   10c0 <swpbyt@plt>
jmp    13c9 <rdsmv+0x179>
test   %r12d,%r12d
je     1dfc <rdsmv+0xbac>
lea    0x163a(%rip),%rdi
call   1060 <puts@plt>
shl    $0x2,%r13d
mov    %r13d,0x4(%rsp)
lea    0x160b(%rip),%rdi
call   1060 <puts@plt>
mov    0x4(%rsp),%esi
lea    0x14ae(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x4(%rsp),%r13d
jmp    1e05 <rdsmv+0xbb5>
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %r15,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
jne    13b8 <rdsmv+0x168>
movslq %r13d,%rbp
movl   $0x1,0x18(%rsp)
xor    %ebx,%ebx
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
add    %rbp,%rbp
mov    %rbp,%rdi
call   1110 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movl   $0x4,(%r14)
test   %r13d,%r13d
jle    215f <rdsmv+0xf0f>
lea    -0x1(%r13),%esi
cmp    $0x38,%esi
jae    1e97 <rdsmv+0xc47>
mov    %rax,%rcx
mov    %r15,%rdx
jmp    20fb <rdsmv+0xeab>
shl    $0x2,%r13d
mov    %r13d,0x4(%rsp)
movslq %r13d,%rdi
call   1110 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movl   $0x5,(%r14)
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
test   %r12d,%r12d
je     1e49 <rdsmv+0xbf9>
mov    (%rsp),%esi
lea    0x1271(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
cmpl   $0x0,(%rsp)
mov    0x20(%rsp),%rbx
je     1e65 <rdsmv+0xc15>
movl   $0xfffffffe,(%rsp)
mov    0x10(%rsp),%rbp
jmp    13c9 <rdsmv+0x179>
movl   $0x1,0x18(%rsp)
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
xor    %eax,%eax
call   1160 <getbo@plt>
cmp    %eax,%ebp
mov    0x10(%rsp),%rbp
je     13c9 <rdsmv+0x179>
jmp    229e <rdsmv+0x104e>
shr    $0x3,%esi
lea    (%rsi,%r15,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    1ec5 <rdsmv+0xc75>
mov    %rsi,%rcx
shl    $0x4,%rcx
lea    (%rcx,%rax,1),%rdi
add    $0x10,%rdi
mov    %rax,%rcx
mov    %r15,%rdx
cmp    %rdi,%r15
jb     20fb <rdsmv+0xeab>
add    $0x1,%esi
mov    %esi,%edi
and    $0xfffffff8,%edi
mov    %rdi,%rdx
shl    $0x4,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    %r15,%rdx
add    %rdi,%rdx
lea    0x0(,%rdi,8),%ebx
xor    %ebp,%ebp
movapd 0x117e(%rip),%xmm12
movq   (%r15,%rbp,1),%xmm13
movdqa %xmm13,%xmm15
pand   0x10fa(%rip),%xmm15
pxor   %xmm0,%xmm0
punpcklbw %xmm0,%xmm15
movdqa %xmm13,%xmm8
pand   0x10f3(%rip),%xmm8
punpcklbw %xmm0,%xmm8
movdqa %xmm13,%xmm5
pand   0x10f1(%rip),%xmm5
punpcklbw %xmm0,%xmm5
movdqa %xmm13,%xmm10
pand   0x10ef(%rip),%xmm10
punpcklbw %xmm0,%xmm10
movdqa %xmm13,%xmm4
pand   0x10ed(%rip),%xmm4
punpcklbw %xmm0,%xmm4
movdqa %xmm13,%xmm11
pand   0x10eb(%rip),%xmm11
punpcklbw %xmm0,%xmm11
pand   0x10ed(%rip),%xmm13
punpcklbw %xmm0,%xmm13
movdqa %xmm5,%xmm0
punpcklwd %xmm10,%xmm0
movdqa %xmm15,%xmm3
punpcklwd %xmm8,%xmm3
movdqa %xmm3,%xmm1
punpckldq %xmm0,%xmm1
movdqa %xmm4,%xmm7
punpcklwd %xmm11,%xmm7
pshufd $0x0,%xmm7,%xmm14
pshufd $0x0,%xmm13,%xmm6
punpckhdq %xmm6,%xmm14
movsd  %xmm1,%xmm14
pshufd $0x55,%xmm0,%xmm1
pshufd $0x55,%xmm3,%xmm6
punpckldq %xmm1,%xmm6
pshufd $0x44,%xmm7,%xmm1
movdqa %xmm13,%xmm2
pslldq $0xa,%xmm2
punpckhdq %xmm2,%xmm1
movsd  %xmm6,%xmm1
pshufd $0xaa,%xmm7,%xmm9
pshufd $0x44,%xmm13,%xmm2
punpckhdq %xmm2,%xmm9
pshufd $0xff,%xmm3,%xmm2
punpckhdq %xmm0,%xmm3
movsd  %xmm3,%xmm9
pshufd $0xff,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
movdqa %xmm13,%xmm0
pslldq $0x6,%xmm0
punpckhdq %xmm0,%xmm7
movsd  %xmm2,%xmm7
punpckhwd %xmm10,%xmm5
punpckhwd %xmm8,%xmm15
movdqa %xmm15,%xmm2
punpckldq %xmm5,%xmm2
punpckhwd %xmm11,%xmm4
pshufd $0x0,%xmm4,%xmm0
pshufd $0xaa,%xmm13,%xmm3
punpckhdq %xmm3,%xmm0
movsd  %xmm2,%xmm0
pshufd $0x55,%xmm5,%xmm2
pshufd $0x55,%xmm15,%xmm3
punpckldq %xmm2,%xmm3
pshufd $0x44,%xmm4,%xmm2
movdqa %xmm13,%xmm6
psllq  $0x10,%xmm6
punpckhdq %xmm6,%xmm2
movsd  %xmm3,%xmm2
pshufd $0xff,%xmm15,%xmm3
punpckhdq %xmm5,%xmm15
pshufd $0xaa,%xmm4,%xmm6
punpckhdq %xmm13,%xmm6
movsd  %xmm15,%xmm6
pshufd $0xff,%xmm5,%xmm5
punpckldq %xmm5,%xmm3
psrld  $0x10,%xmm13
punpckhdq %xmm13,%xmm4
movsd  %xmm3,%xmm4
andpd  %xmm12,%xmm4
movupd %xmm4,0x70(%rax)
andpd  %xmm12,%xmm6
movupd %xmm6,0x60(%rax)
andpd  %xmm12,%xmm2
movupd %xmm2,0x50(%rax)
andpd  %xmm12,%xmm0
movupd %xmm0,0x40(%rax)
andpd  %xmm12,%xmm7
movupd %xmm7,0x30(%rax)
andpd  %xmm12,%xmm9
movupd %xmm9,0x20(%rax)
andpd  %xmm12,%xmm1
movupd %xmm1,0x10(%rax)
andpd  %xmm12,%xmm14
movupd %xmm14,(%rax)
add    $0x8,%rbp
sub    $0xffffffffffffff80,%rax
cmp    %rbp,%rdi
jne    1ef2 <rdsmv+0xca2>
cmp    %rsi,%rdi
je     2152 <rdsmv+0xf02>
movzbl (%rdx),%eax
mov    %eax,%esi
and    $0x2,%esi
mov    %si,(%rcx)
mov    %eax,%esi
and    $0x4,%esi
mov    %si,0x2(%rcx)
mov    %eax,%esi
and    $0x8,%esi
mov    %si,0x4(%rcx)
and    $0x10,%eax
mov    %ax,0x6(%rcx)
movzbl (%rdx),%eax
mov    %eax,%esi
and    $0x20,%esi
mov    %si,0x8(%rcx)
and    $0x40,%eax
mov    %ax,0xa(%rcx)
movzbl (%rdx),%eax
and    $0xffffff80,%eax
mov    %ax,0xc(%rcx)
movw   $0x0,0xe(%rcx)
add    $0x1,%rdx
add    $0x8,%ebx
add    $0x10,%rcx
cmp    %r13d,%ebx
jl     20fb <rdsmv+0xeab>
movl   $0x8,0x2c(%rsp)
mov    0x8(%rsp),%r12d
mov    %r15,%rdi
call   1030 <free@plt>
jmp    13bf <rdsmv+0x16f>
cmpl   $0x0,0x8(%rsp)
je     21ec <rdsmv+0xf9c>
lea    0x11de(%rip),%rbx
mov    %rbx,%rdi
call   1060 <puts@plt>
shl    $0x2,%r13d
mov    %r13d,0x4(%rsp)
mov    %rbx,%rdi
call   1060 <puts@plt>
mov    0x4(%rsp),%esi
lea    0x1081(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x4(%rsp),%r13d
jmp    21f5 <rdsmv+0xfa5>
cmpl   $0x0,0x8(%rsp)
je     220e <rdsmv+0xfbe>
lea    0x1188(%rip),%rbx
mov    %rbx,%rdi
call   1060 <puts@plt>
shl    $0x3,%r13d
mov    %r13d,0x4(%rsp)
mov    %rbx,%rdi
call   1060 <puts@plt>
mov    0x4(%rsp),%esi
lea    0x1041(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x4(%rsp),%r13d
jmp    2217 <rdsmv+0xfc7>
shl    $0x2,%r13d
mov    %r13d,0x4(%rsp)
movslq %r13d,%rdi
call   1110 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movl   $0x7,(%r14)
jmp    222e <rdsmv+0xfde>
shl    $0x3,%r13d
mov    %r13d,0x4(%rsp)
movslq %r13d,%rdi
call   1110 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movl   $0x9,(%r14)
lea    0xc(%rsp),%rdi
lea    0x4(%rsp),%rdx
mov    %rsp,%rcx
mov    %rax,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,0x8(%rsp)
je     225d <rdsmv+0x100d>
mov    (%rsp),%esi
lea    0xe5d(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
cmpl   $0x0,(%rsp)
jne    1513 <rdsmv+0x2c3>
movl   $0x1,0x18(%rsp)
lea    0xc(%rsp),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1100 <dskbwr_@plt>
xor    %eax,%eax
call   1160 <getbo@plt>
cmp    %eax,%ebp
mov    0x8(%rsp),%r12d
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%rbx
je     13c9 <rdsmv+0x179>
test   %r12d,%r12d
je     22af <rdsmv+0x105f>
lea    0x10ef(%rip),%rdi
call   1060 <puts@plt>
mov    0x4(%rsp),%esi
mov    0x10(%rsp),%rbp
mov    0x0(%rbp),%rdx
mov    $0x1,%edi
xor    %eax,%eax
call   10c0 <swpbyt@plt>
mov    0x8(%rsp),%r12d
jmp    13c4 <rdsmv+0x174>
mov    0x38(%rsp),%rax
movslq (%rax),%rcx
mov    %rcx,0x40(%rsp)
mov    0x4(%rax),%r12d
cmpl   $0x0,0x8(%rsp)
je     22f6 <rdsmv+0x10a6>
lea    0x1038(%rip),%rdi
call   1060 <puts@plt>
cmpl   $0x2,0x34(%rsp)
jne    151a <rdsmv+0x2ca>
add    %r13d,%r13d
mov    %r13d,0x4(%rsp)
movslq %r13d,%rdi
call   1110 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
xor    %eax,%eax
call   1160 <getbo@plt>
test   %eax,%eax
je     2337 <rdsmv+0x10e7>
cmp    $0x1,%eax
jne    233e <rdsmv+0x10ee>
mov    $0x1,%eax
jmp    2340 <rdsmv+0x10f0>
mov    $0x1,%eax
jmp    2347 <rdsmv+0x10f7>
xor    %eax,%eax
mov    %rax,0x50(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
movl   $0x2,0x1c(%rsp)
lea    0xc(%rsp),%rdi
lea    0x100(%rsp),%rbp
lea    0x1c(%rsp),%rdx
mov    %rsp,%rcx
mov    %rbp,%rsi
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
jne    1513 <rdsmv+0x2c3>
movslq 0x1c(%rsp),%rax
movzwl -0x2(%rax,%rbp,1),%esi
shl    $0x10,%esi
bswap  %esi
mov    %esi,0x1c(%rsp)
movl   $0x0,0x2c(%rsp)
cmp    $0x2,%r12d
jl     2563 <rdsmv+0x1313>
add    $0xffffffff,%r12d
mov    $0xfffffffe,%ecx
mov    0x40(%rsp),%rax
sub    %eax,%ecx
mov    %ecx,0x5c(%rsp)
lea    (%rsp,%rax,1),%r15
add    $0x100,%r15
add    %eax,%eax
mov    %eax,0x58(%rsp)
lea    0x2900(%rsp),%r13
jmp    23f8 <rdsmv+0x11a8>
movslq 0x1c(%rsp),%rax
movzwl -0x2(%rax,%rbp,1),%esi
shl    $0x10,%esi
bswap  %esi
mov    %esi,0x1c(%rsp)
mov    0x2c(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x2c(%rsp)
cmp    %r12d,%eax
jge    2563 <rdsmv+0x1313>
cmpl   $0x0,0x8(%rsp)
je     2446 <rdsmv+0x11f6>
lea    0xe6a(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0xc(%rsp),%rdi
mov    %rbp,%rsi
lea    0x1c(%rsp),%rdx
mov    %rsp,%rcx
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
jne    1513 <rdsmv+0x2c3>
mov    0x1c(%rsp),%esi
add    0x5c(%rsp),%esi
lea    0xe45(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
jmp    2467 <rdsmv+0x1217>
lea    0xc(%rsp),%rdi
mov    %rbp,%rsi
lea    0x1c(%rsp),%rdx
mov    %rsp,%rcx
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
jne    1513 <rdsmv+0x2c3>
movslq 0x1c(%rsp),%rax
lea    (%rsp,%rax,1),%rcx
add    $0xfe,%rcx
mov    %r13,%rsi
cmp    %rcx,%r15
jae    24ca <rdsmv+0x127a>
mov    %r13,%rsi
mov    %r15,%rcx
jmp    2499 <rdsmv+0x1249>
movslq %eax,%rdx
add    %rsp,%rdx
add    $0xfe,%rdx
cmp    %rdx,%rcx
jae    24ca <rdsmv+0x127a>
movzbl (%rcx),%edx
mov    0x1(%rcx),%bl
add    $0x2,%rcx
movl   $0x0,0x30(%rsp)
test   %edx,%edx
je     2487 <rdsmv+0x1237>
mov    %bl,(%rsi)
add    $0x1,%rsi
mov    0x30(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x30(%rsp)
cmp    %edx,%eax
jl     24af <rdsmv+0x125f>
mov    0x1c(%rsp),%eax
jmp    2487 <rdsmv+0x1237>
cmpl   $0x0,0x8(%rsp)
je     24e2 <rdsmv+0x1292>
sub    %r13,%rsi
lea    0xdbf(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
cmpl   $0x0,0x40(%rsp)
jle    2535 <rdsmv+0x12e5>
mov    0x2c(%rsp),%eax
imul   0x58(%rsp),%eax
cltq
mov    0x10(%rsp),%rcx
add    (%rcx),%rax
mov    0x38(%rsp),%rcx
add    %rax,%rcx
add    0x50(%rsp),%rax
xor    %edx,%edx
movzbl 0x100(%rsp,%rdx,1),%ebx
mov    %bl,(%rax,%rdx,2)
movzbl 0x2900(%rsp,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,2)
lea    (%rsp,%rdx,1),%rsi
add    $0x101,%rsi
add    $0x1,%rdx
cmp    %r15,%rsi
jb     250b <rdsmv+0x12bb>
cmpl   $0x0,0x8(%rsp)
je     23d1 <rdsmv+0x1181>
mov    0x2c(%rsp),%esi
lea    0xd69(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0xdae(%rip),%rdi
call   1060 <puts@plt>
jmp    23d1 <rdsmv+0x1181>
add    $0xfffffffe,%esi
mov    %esi,0x1c(%rsp)
lea    0xc(%rsp),%rdi
lea    0x100(%rsp),%rsi
lea    0x1c(%rsp),%rdx
mov    %rsp,%rcx
xor    %eax,%eax
call   1150 <dskbr_@plt>
cmpl   $0x0,(%rsp)
jne    1513 <rdsmv+0x2c3>
mov    0x40(%rsp),%rax
lea    (%rsp,%rax,1),%rbp
add    $0x100,%rbp
mov    0x1c(%rsp),%ecx
lea    0x2900(%rsp),%rsi
cmp    %ecx,%eax
jge    25f8 <rdsmv+0x13a8>
mov    %rbp,%rax
jmp    25c7 <rdsmv+0x1377>
movslq %ecx,%rdx
add    %rsp,%rdx
add    $0x100,%rdx
cmp    %rdx,%rax
jae    25f8 <rdsmv+0x13a8>
movzbl (%rax),%edx
mov    0x1(%rax),%bl
add    $0x2,%rax
movl   $0x0,0x30(%rsp)
test   %edx,%edx
je     25b5 <rdsmv+0x1365>
mov    %bl,(%rsi)
add    $0x1,%rsi
mov    0x30(%rsp),%ecx
add    $0x1,%ecx
mov    %ecx,0x30(%rsp)
cmp    %edx,%ecx
jl     25dd <rdsmv+0x138d>
mov    0x1c(%rsp),%ecx
jmp    25b5 <rdsmv+0x1365>
cmpl   $0x0,0x8(%rsp)
je     2618 <rdsmv+0x13c8>
lea    0x2900(%rsp),%rax
sub    %rax,%rsi
lea    0xc89(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
cmpl   $0x0,0x40(%rsp)
jle    2670 <rdsmv+0x1420>
mov    0x40(%rsp),%rax
imul   0x2c(%rsp),%eax
add    %eax,%eax
cltq
mov    0x10(%rsp),%rcx
add    (%rcx),%rax
add    %rax,0x38(%rsp)
add    0x50(%rsp),%rax
xor    %ecx,%ecx
mov    0x38(%rsp),%rsi
movzbl 0x100(%rsp,%rcx,1),%edx
mov    %dl,(%rax,%rcx,2)
movzbl 0x2900(%rsp,%rcx,1),%edx
mov    %dl,(%rsi,%rcx,2)
lea    (%rsp,%rcx,1),%rdx
add    $0x101,%rdx
add    $0x1,%rcx
cmp    %rbp,%rdx
jb     2646 <rdsmv+0x13f6>
cmpl   $0x0,0x8(%rsp)
je     2695 <rdsmv+0x1445>
mov    0x2c(%rsp),%esi
lea    0xc32(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0xc75(%rip),%rdi
call   1060 <puts@plt>
mov    0x20(%rsp),%rax
mov    (%rax),%rdx
lea    0xa83(%rip),%rdi
lea    0xb65(%rip),%rsi
xor    %eax,%eax
call   10b0 <puthd@plt>
movl   $0x4,(%r14)
jmp    151a <rdsmv+0x2ca>

LLVM IR (-O0):
@.str = [18 x i8] c"Opening file: %s\0A\00"
@.str.1 = [33 x i8] c"Error opening file %s, istat=%d\0A\00"
@.str.2 = [16 x i8] c"Reading header\0A\00"
@.str.3 = [29 x i8] c"Read Completion status : %d\0A\00"
@.str.4 = [20 x i8] c"Header length : %d\0A\00"
@.str.5 = [4 x i8] c"DIM\00"
@.str.6 = [3 x i8] c"%d\00"
@.str.7 = [26 x i8] c"Error reading dimensions\0A\00"
@.str.8 = [27 x i8] c"Number of dimensions : %d\0A\00"
@.str.9 = [7 x i8] c"SIZE%d\00"
@.str.10 = [18 x i8] c"Error reading %s\0A\00"
@.str.11 = [11 x i8] c"BYTE_ORDER\00"
@.str.12 = [14 x i8] c"little_endian\00"
@.str.13 = [11 x i8] c"big_endian\00"
@.str.14 = [5 x i8] c"TYPE\00"
@.str.15 = [11 x i8] c"Type >%s<\0A\00"
@.str.16 = [16 x i8] c"Image size (%d)\00"
@.str.17 = [5 x i8] c" %d \00"
@.str.18 = [2 x i8] c"\0A\00"
@.str.19 = [25 x i8] c"Number of elements : %d\0A\00"
@.str.20 = [25 x i8] c"Byte order : big_endian\0A\00"
@.str.21 = [28 x i8] c"Byte order : little_endian\0A\00"
@.str.22 = [14 x i8] c"unsigned_byte\00"
@.str.23 = [5 x i8] c"byte\00"
@.str.24 = [14 x i8] c"unsigned_char\00"
@.str.25 = [5 x i8] c"char\00"
@.str.26 = [20 x i8] c"Reading byte image\0A\00"
@.str.27 = [36 x i8] c"Allocating %d bytes for byte image\0A\00"
@.str.28 = [29 x i8] c"Reading unsigned byte image\0A\00"
@.str.29 = [34 x i8] c"Read Byte Completion status : %d\0A\00"
@.str.30 = [37 x i8] c"Allocating %d bytes for short image\0A\00"
@.str.31 = [36 x i8] c"Converting %d bytes to short image\0A\00"
@.str.32 = [4 x i8] c"bit\00"
@.str.33 = [19 x i8] c"Reading bit image\0A\00"
@.str.34 = [4 x i8] c"mad\00"
@.str.35 = [15 x i8] c"unsigned_short\00"
@.str.36 = [30 x i8] c"Reading unsigned short image\0A\00"
@.str.37 = [21 x i8] c"Allocating %d bytes\0A\00"
@.str.38 = [16 x i8] c"Swapping bytes\0A\00"
@.str.39 = [5 x i8] c"long\00"
@.str.40 = [13 x i8] c"long_integer\00"
@.str.41 = [12 x i8] c"signed_long\00"
@.str.42 = [20 x i8] c"Reading long image\0A\00"
@.str.43 = [27 x i8] c"Reading signed long image\0A\00"
@.str.44 = [6 x i8] c"float\00"
@.str.45 = [11 x i8] c"ieee_float\00"
@.str.46 = [21 x i8] c"Reading float image\0A\00"
@.str.47 = [8 x i8] c"complex\00"
@.str.48 = [13 x i8] c"ieee_complex\00"
@.str.49 = [23 x i8] c"Reading complex image\0A\00"
@.str.50 = [11 x i8] c"swap_rlmsb\00"
@.str.51 = [26 x i8] c"Reading compressed image\0A\00"
@.str.52 = [18 x i8] c"Reading %d bytes\0A\00"
@.str.53 = [24 x i8] c"Uncompressing %d bytes\0A\00"
@.str.54 = [23 x i8] c"Line %d, n %d, val %d\0A\00"
@.str.55 = [26 x i8] c"Restored %d bytes in MSB\0A\00"
@.str.56 = [14 x i8] c"Done line %d\0A\00"
@.str.57 = [35 x i8] c"=================================\0A\00"
@.str.58 = [37 x i8] c"===================================\0A\00"
@.str.59 = [22 x i8] c"Unsupported Filetype\0A\00"
@.str.60 = [19 x i8] c"Done reading file\0A\00"
@.str.61 = [28 x i8] c"RDSMV completion status %d\0A\00"
define i32 @rdsmv(i8* %0, i8** %1, i32* %2, i8** %3, i32* %4, i32* %5, i32* %6) {
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i8**
%11 = alloca i32*
%12 = alloca i8**
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca [80 x i8]
%24 = alloca [80 x i8]
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i8*
%29 = alloca i32
%30 = alloca i32
%31 = alloca i8*
%32 = alloca i8*
%33 = alloca i16*
%34 = alloca i32
%35 = alloca i8*
%36 = alloca i8*
%37 = alloca i16*
%38 = alloca [10240 x i8]
%39 = alloca [10240 x i8]
%40 = alloca i8*
%41 = alloca i8*
%42 = alloca i8*
%43 = alloca i8*
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
store i8* %0, i8** %9
store i8** %1, i8*** %10
store i32* %2, i32** %11
store i8** %3, i8*** %12
store i32* %4, i32** %13
store i32* %5, i32** %14
store i32* %6, i32** %15
store i32 1, i32* %25
%51 = call i32 (...) @filec_getdebug()
store i32 %51, i32* %29
%52 = load i8**, i8*** %10
store i8* null, i8** %52
%53 = load i8**, i8*** %12
store i8* null, i8** %53
%54 = load i8*, i8** %9
%55 = call i64 @strlen(i8* %54)
%56 = trunc i64 %55 to i32
store i32 %56, i32* %18
%57 = load i32, i32* %29
%58 = icmp ne i32 %57, 0
br i1 %58, label %59, label %62
59: ; preds = %7
%60 = load i8*, i8** %9
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %60)
br label %62
62: ; preds = %59, %7
%63 = load i8*, i8** %9
%64 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbor_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %63, i32* %18, i32* %20)
%65 = load i32, i32* %20
%66 = icmp ne i32 %65, 0
br i1 %66, label %67, label %75
67: ; preds = %62
%68 = load i32, i32* %29
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %74
70: ; preds = %67
%71 = load i8*, i8** %9
%72 = load i32, i32* %20
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i8* %71, i32 %72)
br label %74
74: ; preds = %70, %67
store i32 -3, i32* %8
br label %1052
75: ; preds = %62
store i32 1, i32* %26
%76 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
store i32 512, i32* %16
%77 = call i8* @malloc(i64 512)
store i8* %77, i8** %28
%78 = load i8*, i8** %28
%79 = load i32, i32* %29
%80 = icmp ne i32 %79, 0
br i1 %80, label %81, label %83
81: ; preds = %75
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0))
br label %83
83: ; preds = %81, %75
%84 = load i8*, i8** %28
%85 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %84, i32* %16, i32* %20)
%86 = load i32, i32* %29
%87 = icmp ne i32 %86, 0
br i1 %87, label %88, label %91
88: ; preds = %83
%89 = load i32, i32* %20
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %89)
br label %91
91: ; preds = %88, %83
%92 = load i32, i32* %20
%93 = icmp ne i32 %92, 0
br i1 %93, label %94, label %95
94: ; preds = %91
store i32 -2, i32* %20
br label %1018
95: ; preds = %91
%96 = load i8*, i8** %28
%97 = call i32 (i32*, i8*, ...) bitcast (i32 (...)* @gethdl to i32 (i32*, i8*, ...)*)(i32* %19, i8* %96)
store i32 %97, i32* %20
%98 = icmp slt i32 %97, 0
br i1 %98, label %99, label %100
99: ; preds = %95
store i32 -4, i32* %20
br label %1018
100: ; preds = %95
%101 = load i32, i32* %29
%102 = icmp ne i32 %101, 0
br i1 %102, label %103, label %106
103: ; preds = %100
%104 = load i32, i32* %19
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0), i32 %104)
br label %106
106: ; preds = %103, %100
%107 = load i32, i32* %19
%108 = sdiv i32 %107, 1024
%109 = add nsw i32 %108, 1
%110 = mul nsw i32 %109, 1024
%111 = load i32*, i32** %11
store i32 %110, i32* %111
%112 = load i32*, i32** %11
%113 = load i32, i32* %112
%114 = sext i32 %113 to i64
%115 = call i8* @malloc(i64 %114)
%116 = load i8**, i8*** %10
store i8* %115, i8** %116
%117 = load i8**, i8*** %10
%118 = load i8*, i8** %117
%119 = load i32*, i32** %11
%120 = load i32, i32* %119
%121 = sext i32 %120 to i64
%122 = load i8**, i8*** %10
%123 = load i8*, i8** %122
%124 = load i8*, i8** %28
%125 = load i8*, i8** %28
%126 = load i32, i32* %19
%127 = sub nsw i32 %126, 512
store i32 %127, i32* %16
%128 = load i32, i32* %16
%129 = icmp sgt i32 %128, 0
br i1 %129, label %130, label %139
130: ; preds = %106
%131 = load i8**, i8*** %10
%132 = load i8*, i8** %131
%133 = getelementptr inbounds i8, i8* %132, i64 512
%134 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %133, i32* %16, i32* %20)
%135 = load i32, i32* %20
%136 = icmp ne i32 %135, 0
br i1 %136, label %137, label %138
137: ; preds = %130
store i32 -2, i32* %20
br label %1018
138: ; preds = %130
br label %139
139: ; preds = %138, %106
store i32 0, i32* %26
%140 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%141 = load i32*, i32** %13
store i32 0, i32* %141
%142 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%143 = load i8**, i8*** %10
%144 = load i8*, i8** %143
%145 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i8* %142, i8* %144)
%146 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%147 = load i8, i8* %146
%148 = sext i8 %147 to i32
%149 = icmp eq i32 %148, 0
br i1 %149, label %154, label %150
150: ; preds = %139
%151 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%152 = call i32 (i8*, i8*, ...) @sscanf(i8* %151, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %22)
%153 = icmp ne i32 %152, 1
br i1 %153, label %154, label %160
154: ; preds = %150, %139
%155 = load i32, i32* %29
%156 = icmp ne i32 %155, 0
br i1 %156, label %157, label %159
157: ; preds = %154
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0))
br label %159
159: ; preds = %157, %154
br label %1018
160: ; preds = %150
%161 = load i32, i32* %29
%162 = icmp ne i32 %161, 0
br i1 %162, label %163, label %166
163: ; preds = %160
%164 = load i32, i32* %22
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.8, i64 0, i64 0), i32 %164)
br label %166
166: ; preds = %163, %160
%167 = load i32, i32* %22
%168 = load i32*, i32** %13
store i32 %167, i32* %168
store i32 0, i32* %17
store i32 1, i32* %27
br label %169
169: ; preds = %210, %166
%170 = load i32, i32* %17
%171 = load i32, i32* %22
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %213
173: ; preds = %169
%174 = getelementptr inbounds [80 x i8], [80 x i8]* %24, i64 0, i64 0
%175 = load i32, i32* %17
%176 = add nsw i32 %175, 1
%177 = call i32 (i8*, i8*, ...) @sprintf(i8* %174, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i32 %176)
%178 = getelementptr inbounds [80 x i8], [80 x i8]* %24, i64 0, i64 0
%179 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%180 = load i8**, i8*** %10
%181 = load i8*, i8** %180
%182 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* %178, i8* %179, i8* %181)
%183 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = icmp eq i32 %185, 0
br i1 %186, label %195, label %187
187: ; preds = %173
%188 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%189 = load i32*, i32** %14
%190 = load i32, i32* %17
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %189, i64 %191
%193 = call i32 (i8*, i8*, ...) @sscanf(i8* %188, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %192)
%194 = icmp ne i32 %193, 1
br i1 %194, label %195, label %202
195: ; preds = %187, %173
%196 = load i32, i32* %29
%197 = icmp ne i32 %196, 0
br i1 %197, label %198, label %201
198: ; preds = %195
%199 = getelementptr inbounds [80 x i8], [80 x i8]* %24, i64 0, i64 0
%200 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0), i8* %199)
br label %201
201: ; preds = %198, %195
br label %1018
202: ; preds = %187
%203 = load i32*, i32** %14
%204 = load i32, i32* %17
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %203, i64 %205
%207 = load i32, i32* %206
%208 = load i32, i32* %27
%209 = mul nsw i32 %208, %207
store i32 %209, i32* %27
br label %210
210: ; preds = %202
%211 = load i32, i32* %17
%212 = add nsw i32 %211, 1
store i32 %212, i32* %17
br label %169
213: ; preds = %169
%214 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%215 = load i8**, i8*** %10
%216 = load i8*, i8** %215
%217 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i64 0, i64 0), i8* %214, i8* %216)
%218 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%219 = load i8, i8* %218
%220 = icmp ne i8 %219, 0
br i1 %220, label %221, label %234
221: ; preds = %213
%222 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%223 = call i32 @strcmp(i8* %222, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %226
225: ; preds = %221
store i32 0, i32* %21
br label %233
226: ; preds = %221
%227 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%228 = call i32 @strcmp(i8* %227, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0))
%229 = icmp eq i32 %228, 0
br i1 %229, label %230, label %231
230: ; preds = %226
store i32 1, i32* %21
br label %232
231: ; preds = %226
store i32 -4, i32* %20
br label %1018
232: ; preds = %230
br label %233
233: ; preds = %232, %225
br label %235
234: ; preds = %213
store i32 -1, i32* %21
br label %235
235: ; preds = %234, %233
%236 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%237 = load i8**, i8*** %10
%238 = load i8*, i8** %237
%239 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), i8* %236, i8* %238)
%240 = load i32, i32* %29
%241 = icmp ne i32 %240, 0
br i1 %241, label %242, label %272
242: ; preds = %235
%243 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), i8* %243)
%245 = load i32, i32* %22
%246 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0), i32 %245)
store i32 0, i32* %17
br label %247
247: ; preds = %258, %242
%248 = load i32, i32* %17
%249 = load i32, i32* %22
%250 = icmp slt i32 %248, %249
br i1 %250, label %251, label %261
251: ; preds = %247
%252 = load i32*, i32** %14
%253 = load i32, i32* %17
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %252, i64 %254
%256 = load i32, i32* %255
%257 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0), i32 %256)
br label %258
258: ; preds = %251
%259 = load i32, i32* %17
%260 = add nsw i32 %259, 1
store i32 %260, i32* %17
br label %247
261: ; preds = %247
%262 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
%263 = load i32, i32* %27
%264 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.19, i64 0, i64 0), i32 %263)
%265 = load i32, i32* %21
%266 = icmp ne i32 %265, 0
br i1 %266, label %267, label %269
267: ; preds = %261
%268 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.20, i64 0, i64 0))
br label %271
269: ; preds = %261
%270 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.21, i64 0, i64 0))
br label %271
271: ; preds = %269, %267
br label %272
272: ; preds = %271, %235
%273 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%274 = call i32 @strcmp(i8* %273, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.22, i64 0, i64 0))
%275 = icmp eq i32 %274, 0
br i1 %275, label %288, label %276
276: ; preds = %272
%277 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%278 = call i32 @strcmp(i8* %277, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i64 0, i64 0))
%279 = icmp eq i32 %278, 0
br i1 %279, label %288, label %280
280: ; preds = %276
%281 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%282 = call i32 @strcmp(i8* %281, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.24, i64 0, i64 0))
%283 = icmp eq i32 %282, 0
br i1 %283, label %288, label %284
284: ; preds = %280
%285 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%286 = call i32 @strcmp(i8* %285, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.25, i64 0, i64 0))
%287 = icmp eq i32 %286, 0
br i1 %287, label %288, label %363
288: ; preds = %284, %280, %276, %272
%289 = load i32, i32* %29
%290 = icmp ne i32 %289, 0
br i1 %290, label %291, label %293
291: ; preds = %288
%292 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.26, i64 0, i64 0))
br label %293
293: ; preds = %291, %288
%294 = load i32, i32* %27
%295 = sext i32 %294 to i64
%296 = mul i64 %295, 1
%297 = trunc i64 %296 to i32
store i32 %297, i32* %16
%298 = load i32, i32* %16
%299 = sext i32 %298 to i64
%300 = call i8* @malloc(i64 %299)
store i8* %300, i8** %31
%301 = load i32, i32* %29
%302 = icmp ne i32 %301, 0
br i1 %302, label %303, label %307
303: ; preds = %293
%304 = load i32, i32* %16
%305 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.27, i64 0, i64 0), i32 %304)
%306 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.28, i64 0, i64 0))
br label %307
307: ; preds = %303, %293
%308 = load i8*, i8** %31
%309 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %308, i32* %16, i32* %20)
%310 = load i32, i32* %29
%311 = icmp ne i32 %310, 0
br i1 %311, label %312, label %315
312: ; preds = %307
%313 = load i32, i32* %20
%314 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.29, i64 0, i64 0), i32 %313)
br label %315
315: ; preds = %312, %307
%316 = load i32, i32* %20
%317 = icmp ne i32 %316, 0
br i1 %317, label %318, label %319
318: ; preds = %315
store i32 -2, i32* %20
br label %1018
319: ; preds = %315
store i32 1, i32* %26
%320 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%321 = load i32, i32* %29
%322 = icmp ne i32 %321, 0
br i1 %322, label %323, label %330
323: ; preds = %319
%324 = load i32, i32* %27
%325 = sext i32 %324 to i64
%326 = mul i64 %325, 2
%327 = trunc i64 %326 to i32
store i32 %327, i32* %16
%328 = load i32, i32* %16
%329 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.30, i64 0, i64 0), i32 %328)
br label %330
330: ; preds = %323, %319
%331 = load i32, i32* %27
%332 = sext i32 %331 to i64
%333 = mul i64 %332, 2
%334 = call i8* @malloc(i64 %333)
%335 = load i8**, i8*** %12
store i8* %334, i8** %335
%336 = load i32*, i32** %15
store i32 4, i32* %336
%337 = load i8**, i8*** %12
%338 = load i8*, i8** %337
%339 = bitcast i8* %338 to i16*
store i16* %339, i16** %33
%340 = load i8*, i8** %31
store i8* %340, i8** %32
%341 = load i32, i32* %29
%342 = icmp ne i32 %341, 0
br i1 %342, label %343, label %346
343: ; preds = %330
%344 = load i32, i32* %27
%345 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.31, i64 0, i64 0), i32 %344)
br label %346
346: ; preds = %343, %330
store i32 0, i32* %30
br label %347
347: ; preds = %358, %346
%348 = load i32, i32* %30
%349 = load i32, i32* %27
%350 = icmp slt i32 %348, %349
br i1 %350, label %351, label %361
351: ; preds = %347
%352 = load i8*, i8** %32
%353 = getelementptr inbounds i8, i8* %352, i32 1
store i8* %353, i8** %32
%354 = load i8, i8* %352
%355 = zext i8 %354 to i16
%356 = load i16*, i16** %33
%357 = getelementptr inbounds i16, i16* %356, i32 1
store i16* %357, i16** %33
store i16 %355, i16* %356
br label %358
358: ; preds = %351
%359 = load i32, i32* %30
%360 = add nsw i32 %359, 1
store i32 %360, i32* %30
br label %347
361: ; preds = %347
%362 = load i8*, i8** %31
br label %1017
363: ; preds = %284
%364 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%365 = call i32 @strcmp(i8* %364, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.32, i64 0, i64 0))
%366 = icmp eq i32 %365, 0
br i1 %366, label %367, label %438
367: ; preds = %363
%368 = load i32, i32* %29
%369 = icmp ne i32 %368, 0
br i1 %369, label %370, label %372
370: ; preds = %367
%371 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.33, i64 0, i64 0))
br label %372
372: ; preds = %370, %367
%373 = load i32, i32* %27
%374 = sext i32 %373 to i64
%375 = mul i64 %374, 1
%376 = udiv i64 %375, 8
%377 = trunc i64 %376 to i32
store i32 %377, i32* %16
%378 = load i32, i32* %16
%379 = sext i32 %378 to i64
%380 = call i8* @malloc(i64 %379)
store i8* %380, i8** %35
%381 = load i32, i32* %29
%382 = icmp ne i32 %381, 0
br i1 %382, label %383, label %385
383: ; preds = %372
%384 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.33, i64 0, i64 0))
br label %385
385: ; preds = %383, %372
%386 = load i8*, i8** %35
%387 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %386, i32* %16, i32* %20)
%388 = load i32, i32* %29
%389 = icmp ne i32 %388, 0
br i1 %389, label %390, label %393
390: ; preds = %385
%391 = load i32, i32* %20
%392 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %391)
br label %393
393: ; preds = %390, %385
%394 = load i32, i32* %20
%395 = icmp ne i32 %394, 0
br i1 %395, label %396, label %397
396: ; preds = %393
store i32 -2, i32* %20
br label %1018
397: ; preds = %393
store i32 1, i32* %26
%398 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%399 = load i32, i32* %27
%400 = sext i32 %399 to i64
%401 = mul i64 %400, 2
%402 = call i8* @malloc(i64 %401)
%403 = load i8**, i8*** %12
store i8* %402, i8** %403
%404 = load i32*, i32** %15
store i32 4, i32* %404
%405 = load i8**, i8*** %12
%406 = load i8*, i8** %405
%407 = bitcast i8* %406 to i16*
store i16* %407, i16** %37
%408 = load i8*, i8** %35
store i8* %408, i8** %36
store i32 0, i32* %34
br label %409
409: ; preds = %433, %397
%410 = load i32, i32* %34
%411 = load i32, i32* %27
%412 = icmp slt i32 %410, %411
br i1 %412, label %413, label %436
413: ; preds = %409
store i32 0, i32* %18
br label %414
414: ; preds = %427, %413
%415 = load i32, i32* %18
%416 = icmp slt i32 %415, 8
br i1 %416, label %417, label %430
417: ; preds = %414
%418 = load i8*, i8** %36
%419 = load i8, i8* %418
%420 = zext i8 %419 to i32
%421 = load i32, i32* %18
%422 = shl i32 2, %421
%423 = and i32 %420, %422
%424 = trunc i32 %423 to i16
%425 = load i16*, i16** %37
%426 = getelementptr inbounds i16, i16* %425, i32 1
store i16* %426, i16** %37
store i16 %424, i16* %425
br label %427
427: ; preds = %417
%428 = load i32, i32* %18
%429 = add nsw i32 %428, 1
store i32 %429, i32* %18
br label %414
430: ; preds = %414
%431 = load i8*, i8** %36
%432 = getelementptr inbounds i8, i8* %431, i32 1
store i8* %432, i8** %36
br label %433
433: ; preds = %430
%434 = load i32, i32* %34
%435 = add nsw i32 %434, 8
store i32 %435, i32* %34
br label %409
436: ; preds = %409
%437 = load i8*, i8** %35
br label %1016
438: ; preds = %363
%439 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%440 = call i32 @strcmp(i8* %439, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%441 = icmp eq i32 %440, 0
br i1 %441, label %446, label %442
442: ; preds = %438
%443 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%444 = call i32 @strcmp(i8* %443, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.35, i64 0, i64 0))
%445 = icmp eq i32 %444, 0
br i1 %445, label %446, label %496
446: ; preds = %442, %438
%447 = load i32, i32* %29
%448 = icmp ne i32 %447, 0
br i1 %448, label %449, label %451
449: ; preds = %446
%450 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.36, i64 0, i64 0))
br label %451
451: ; preds = %449, %446
%452 = load i32, i32* %27
%453 = sext i32 %452 to i64
%454 = mul i64 %453, 2
%455 = trunc i64 %454 to i32
store i32 %455, i32* %16
%456 = load i32, i32* %29
%457 = icmp ne i32 %456, 0
br i1 %457, label %458, label %462
458: ; preds = %451
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.36, i64 0, i64 0))
%460 = load i32, i32* %16
%461 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %460)
br label %462
462: ; preds = %458, %451
%463 = load i32, i32* %16
%464 = sext i32 %463 to i64
%465 = call i8* @malloc(i64 %464)
%466 = load i8**, i8*** %12
store i8* %465, i8** %466
%467 = load i32*, i32** %15
store i32 4, i32* %467
%468 = load i8**, i8*** %12
%469 = load i8*, i8** %468
%470 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %469, i32* %16, i32* %20)
%471 = load i32, i32* %29
%472 = icmp ne i32 %471, 0
br i1 %472, label %473, label %476
473: ; preds = %462
%474 = load i32, i32* %20
%475 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %474)
br label %476
476: ; preds = %473, %462
%477 = load i32, i32* %20
%478 = icmp ne i32 %477, 0
br i1 %478, label %479, label %480
479: ; preds = %476
store i32 -2, i32* %20
br label %1018
480: ; preds = %476
store i32 1, i32* %26
%481 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%482 = load i32, i32* %21
%483 = call i32 (...) @getbo()
%484 = icmp ne i32 %482, %483
br i1 %484, label %485, label %495
485: ; preds = %480
%486 = load i32, i32* %29
%487 = icmp ne i32 %486, 0
br i1 %487, label %488, label %490
488: ; preds = %485
%489 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.38, i64 0, i64 0))
br label %490
490: ; preds = %488, %485
%491 = load i32, i32* %16
%492 = load i8**, i8*** %12
%493 = load i8*, i8** %492
%494 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 0, i32 %491, i8* %493)
br label %495
495: ; preds = %490, %480
br label %1015
496: ; preds = %442
%497 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%498 = call i32 @strcmp(i8* %497, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%499 = icmp eq i32 %498, 0
br i1 %499, label %508, label %500
500: ; preds = %496
%501 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%502 = call i32 @strcmp(i8* %501, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.40, i64 0, i64 0))
%503 = icmp eq i32 %502, 0
br i1 %503, label %508, label %504
504: ; preds = %500
%505 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%506 = call i32 @strcmp(i8* %505, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0))
%507 = icmp eq i32 %506, 0
br i1 %507, label %508, label %558
508: ; preds = %504, %500, %496
%509 = load i32, i32* %29
%510 = icmp ne i32 %509, 0
br i1 %510, label %511, label %513
511: ; preds = %508
%512 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.42, i64 0, i64 0))
br label %513
513: ; preds = %511, %508
%514 = load i32, i32* %27
%515 = sext i32 %514 to i64
%516 = mul i64 %515, 4
%517 = trunc i64 %516 to i32
store i32 %517, i32* %16
%518 = load i32, i32* %29
%519 = icmp ne i32 %518, 0
br i1 %519, label %520, label %524
520: ; preds = %513
%521 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.43, i64 0, i64 0))
%522 = load i32, i32* %16
%523 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %522)
br label %524
524: ; preds = %520, %513
%525 = load i32, i32* %16
%526 = sext i32 %525 to i64
%527 = call i8* @malloc(i64 %526)
%528 = load i8**, i8*** %12
store i8* %527, i8** %528
%529 = load i32*, i32** %15
store i32 5, i32* %529
%530 = load i8**, i8*** %12
%531 = load i8*, i8** %530
%532 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %531, i32* %16, i32* %20)
%533 = load i32, i32* %29
%534 = icmp ne i32 %533, 0
br i1 %534, label %535, label %538
535: ; preds = %524
%536 = load i32, i32* %20
%537 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %536)
br label %538
538: ; preds = %535, %524
%539 = load i32, i32* %20
%540 = icmp ne i32 %539, 0
br i1 %540, label %541, label %542
541: ; preds = %538
store i32 -2, i32* %20
br label %1018
542: ; preds = %538
store i32 1, i32* %26
%543 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%544 = load i32, i32* %21
%545 = call i32 (...) @getbo()
%546 = icmp ne i32 %544, %545
br i1 %546, label %547, label %557
547: ; preds = %542
%548 = load i32, i32* %29
%549 = icmp ne i32 %548, 0
br i1 %549, label %550, label %552
550: ; preds = %547
%551 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.38, i64 0, i64 0))
br label %552
552: ; preds = %550, %547
%553 = load i32, i32* %16
%554 = load i8**, i8*** %12
%555 = load i8*, i8** %554
%556 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 1, i32 %553, i8* %555)
br label %557
557: ; preds = %552, %542
br label %1014
558: ; preds = %504
%559 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%560 = call i32 @strcmp(i8* %559, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.44, i64 0, i64 0))
%561 = icmp eq i32 %560, 0
br i1 %561, label %566, label %562
562: ; preds = %558
%563 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%564 = call i32 @strcmp(i8* %563, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.45, i64 0, i64 0))
%565 = icmp eq i32 %564, 0
br i1 %565, label %566, label %616
566: ; preds = %562, %558
%567 = load i32, i32* %29
%568 = icmp ne i32 %567, 0
br i1 %568, label %569, label %571
569: ; preds = %566
%570 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.46, i64 0, i64 0))
br label %571
571: ; preds = %569, %566
%572 = load i32, i32* %27
%573 = sext i32 %572 to i64
%574 = mul i64 %573, 4
%575 = trunc i64 %574 to i32
store i32 %575, i32* %16
%576 = load i32, i32* %29
%577 = icmp ne i32 %576, 0
br i1 %577, label %578, label %582
578: ; preds = %571
%579 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.46, i64 0, i64 0))
%580 = load i32, i32* %16
%581 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %580)
br label %582
582: ; preds = %578, %571
%583 = load i32, i32* %16
%584 = sext i32 %583 to i64
%585 = call i8* @malloc(i64 %584)
%586 = load i8**, i8*** %12
store i8* %585, i8** %586
%587 = load i32*, i32** %15
store i32 7, i32* %587
%588 = load i8**, i8*** %12
%589 = load i8*, i8** %588
%590 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %589, i32* %16, i32* %20)
%591 = load i32, i32* %29
%592 = icmp ne i32 %591, 0
br i1 %592, label %593, label %596
593: ; preds = %582
%594 = load i32, i32* %20
%595 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %594)
br label %596
596: ; preds = %593, %582
%597 = load i32, i32* %20
%598 = icmp ne i32 %597, 0
br i1 %598, label %599, label %600
599: ; preds = %596
store i32 -2, i32* %20
br label %1018
600: ; preds = %596
store i32 1, i32* %26
%601 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%602 = load i32, i32* %21
%603 = call i32 (...) @getbo()
%604 = icmp ne i32 %602, %603
br i1 %604, label %605, label %615
605: ; preds = %600
%606 = load i32, i32* %29
%607 = icmp ne i32 %606, 0
br i1 %607, label %608, label %610
608: ; preds = %605
%609 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.38, i64 0, i64 0))
br label %610
610: ; preds = %608, %605
%611 = load i32, i32* %16
%612 = load i8**, i8*** %12
%613 = load i8*, i8** %612
%614 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 1, i32 %611, i8* %613)
br label %615
615: ; preds = %610, %600
br label %1013
616: ; preds = %562
%617 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%618 = call i32 @strcmp(i8* %617, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0))
%619 = icmp eq i32 %618, 0
br i1 %619, label %624, label %620
620: ; preds = %616
%621 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%622 = call i32 @strcmp(i8* %621, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.48, i64 0, i64 0))
%623 = icmp eq i32 %622, 0
br i1 %623, label %624, label %675
624: ; preds = %620, %616
%625 = load i32, i32* %29
%626 = icmp ne i32 %625, 0
br i1 %626, label %627, label %629
627: ; preds = %624
%628 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.49, i64 0, i64 0))
br label %629
629: ; preds = %627, %624
%630 = load i32, i32* %27
%631 = mul nsw i32 %630, 2
%632 = sext i32 %631 to i64
%633 = mul i64 %632, 4
%634 = trunc i64 %633 to i32
store i32 %634, i32* %16
%635 = load i32, i32* %29
%636 = icmp ne i32 %635, 0
br i1 %636, label %637, label %641
637: ; preds = %629
%638 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.49, i64 0, i64 0))
%639 = load i32, i32* %16
%640 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %639)
br label %641
641: ; preds = %637, %629
%642 = load i32, i32* %16
%643 = sext i32 %642 to i64
%644 = call i8* @malloc(i64 %643)
%645 = load i8**, i8*** %12
store i8* %644, i8** %645
%646 = load i32*, i32** %15
store i32 9, i32* %646
%647 = load i8**, i8*** %12
%648 = load i8*, i8** %647
%649 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %648, i32* %16, i32* %20)
%650 = load i32, i32* %29
%651 = icmp ne i32 %650, 0
br i1 %651, label %652, label %655
652: ; preds = %641
%653 = load i32, i32* %20
%654 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %653)
br label %655
655: ; preds = %652, %641
%656 = load i32, i32* %20
%657 = icmp ne i32 %656, 0
br i1 %657, label %658, label %659
658: ; preds = %655
store i32 -2, i32* %20
br label %1018
659: ; preds = %655
store i32 1, i32* %26
%660 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %26)
%661 = load i32, i32* %21
%662 = call i32 (...) @getbo()
%663 = icmp ne i32 %661, %662
br i1 %663, label %664, label %674
664: ; preds = %659
%665 = load i32, i32* %29
%666 = icmp ne i32 %665, 0
br i1 %666, label %667, label %669
667: ; preds = %664
%668 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.38, i64 0, i64 0))
br label %669
669: ; preds = %667, %664
%670 = load i32, i32* %16
%671 = load i8**, i8*** %12
%672 = load i8*, i8** %671
%673 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 1, i32 %670, i8* %672)
br label %674
674: ; preds = %669, %659
br label %1012
675: ; preds = %620
%676 = getelementptr inbounds [80 x i8], [80 x i8]* %23, i64 0, i64 0
%677 = call i32 @strcmp(i8* %676, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.50, i64 0, i64 0))
%678 = icmp eq i32 %677, 0
br i1 %678, label %679, label %1005
679: ; preds = %675
store i32 0, i32* %44
store i32 0, i32* %45
%680 = load i32*, i32** %14
%681 = getelementptr inbounds i32, i32* %680, i64 0
%682 = load i32, i32* %681
store i32 %682, i32* %49
%683 = load i32*, i32** %14
%684 = getelementptr inbounds i32, i32* %683, i64 1
%685 = load i32, i32* %684
store i32 %685, i32* %50
%686 = load i32, i32* %29
%687 = icmp ne i32 %686, 0
br i1 %687, label %688, label %690
688: ; preds = %679
%689 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.51, i64 0, i64 0))
br label %690
690: ; preds = %688, %679
%691 = load i32, i32* %22
%692 = icmp ne i32 %691, 2
br i1 %692, label %693, label %694
693: ; preds = %690
br label %1018
694: ; preds = %690
%695 = load i32, i32* %27
%696 = sext i32 %695 to i64
%697 = mul i64 %696, 2
%698 = trunc i64 %697 to i32
store i32 %698, i32* %16
%699 = load i32, i32* %16
%700 = sext i32 %699 to i64
%701 = call i8* @malloc(i64 %700)
%702 = load i8**, i8*** %12
store i8* %701, i8** %702
%703 = call i32 (...) @getbo()
store i32 %703, i32* %21
%704 = load i32, i32* %21
%705 = icmp eq i32 %704, 0
br i1 %705, label %706, label %707
706: ; preds = %694
store i32 0, i32* %44
store i32 1, i32* %45
br label %712
707: ; preds = %694
%708 = load i32, i32* %21
%709 = icmp eq i32 %708, 1
br i1 %709, label %710, label %711
710: ; preds = %707
store i32 1, i32* %44
store i32 0, i32* %45
br label %711
711: ; preds = %710, %707
br label %712
712: ; preds = %711, %706
store i32 2, i32* %46
%713 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%714 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %713, i32* %46, i32* %20)
%715 = load i32, i32* %20
%716 = icmp ne i32 %715, 0
br i1 %716, label %717, label %718
717: ; preds = %712
store i32 -2, i32* %20
br label %1018
718: ; preds = %712
%719 = load i32, i32* %46
%720 = sub nsw i32 %719, 2
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 %721
%723 = load i8, i8* %722
%724 = zext i8 %723 to i32
%725 = mul nsw i32 %724, 256
%726 = load i32, i32* %46
%727 = sub nsw i32 %726, 1
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 %728
%730 = load i8, i8* %729
%731 = zext i8 %730 to i32
%732 = add nsw i32 %725, %731
store i32 %732, i32* %46
store i32 0, i32* %18
br label %733
733: ; preds = %882, %718
%734 = load i32, i32* %18
%735 = load i32, i32* %50
%736 = sub nsw i32 %735, 1
%737 = icmp slt i32 %734, %736
br i1 %737, label %738, label %885
738: ; preds = %733
%739 = load i32, i32* %29
%740 = icmp ne i32 %739, 0
br i1 %740, label %741, label %744
741: ; preds = %738
%742 = load i32, i32* %46
%743 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.52, i64 0, i64 0), i32 %742)
br label %744
744: ; preds = %741, %738
%745 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%746 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %745, i32* %46, i32* %20)
%747 = load i32, i32* %20
%748 = icmp ne i32 %747, 0
br i1 %748, label %749, label %750
749: ; preds = %744
store i32 -2, i32* %20
br label %1018
750: ; preds = %744
%751 = load i32, i32* %29
%752 = icmp ne i32 %751, 0
br i1 %752, label %753, label %759
753: ; preds = %750
%754 = load i32, i32* %46
%755 = load i32, i32* %49
%756 = sub nsw i32 %754, %755
%757 = sub nsw i32 %756, 2
%758 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.53, i64 0, i64 0), i32 %757)
br label %759
759: ; preds = %753, %750
%760 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%761 = load i32, i32* %49
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds i8, i8* %760, i64 %762
store i8* %763, i8** %40
%764 = getelementptr inbounds [10240 x i8], [10240 x i8]* %39, i64 0, i64 0
store i8* %764, i8** %41
br label %765
765: ; preds = %803, %759
%766 = load i8*, i8** %40
%767 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%768 = load i32, i32* %46
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds i8, i8* %767, i64 %769
%771 = getelementptr inbounds i8, i8* %770, i64 -2
%772 = icmp ult i8* %766, %771
br i1 %772, label %773, label %804
773: ; preds = %765
%774 = load i8*, i8** %40
%775 = getelementptr inbounds i8, i8* %774, i32 1
store i8* %775, i8** %40
%776 = load i8, i8* %774
%777 = zext i8 %776 to i32
store i32 %777, i32* %47
%778 = load i8*, i8** %40
%779 = getelementptr inbounds i8, i8* %778, i32 1
store i8* %779, i8** %40
%780 = load i8, i8* %778
%781 = zext i8 %780 to i32
store i32 %781, i32* %48
%782 = load i32, i32* %29
%783 = icmp ne i32 %782, 0
br i1 %783, label %784, label %790
784: ; preds = %773
br i1 false, label %785, label %790
785: ; preds = %784
%786 = load i32, i32* %18
%787 = load i32, i32* %47
%788 = load i32, i32* %48
%789 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.54, i64 0, i64 0), i32 %786, i32 %787, i32 %788)
br label %790
790: ; preds = %785, %784, %773
store i32 0, i32* %17
br label %791
791: ; preds = %800, %790
%792 = load i32, i32* %17
%793 = load i32, i32* %47
%794 = icmp slt i32 %792, %793
br i1 %794, label %795, label %803
795: ; preds = %791
%796 = load i32, i32* %48
%797 = trunc i32 %796 to i8
%798 = load i8*, i8** %41
%799 = getelementptr inbounds i8, i8* %798, i32 1
store i8* %799, i8** %41
store i8 %797, i8* %798
br label %800
800: ; preds = %795
%801 = load i32, i32* %17
%802 = add nsw i32 %801, 1
store i32 %802, i32* %17
br label %791
803: ; preds = %791
br label %765
804: ; preds = %765
%805 = load i32, i32* %29
%806 = icmp ne i32 %805, 0
br i1 %806, label %807, label %814
807: ; preds = %804
%808 = load i8*, i8** %41
%809 = getelementptr inbounds [10240 x i8], [10240 x i8]* %39, i64 0, i64 0
%810 = ptrtoint i8* %808 to i64
%811 = ptrtoint i8* %809 to i64
%812 = sub i64 %810, %811
%813 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.55, i64 0, i64 0), i64 %812)
br label %814
814: ; preds = %807, %804
%815 = load i8**, i8*** %12
%816 = load i8*, i8** %815
%817 = load i32, i32* %18
%818 = mul nsw i32 2, %817
%819 = load i32, i32* %49
%820 = mul nsw i32 %818, %819
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds i8, i8* %816, i64 %821
%823 = load i32, i32* %44
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds i8, i8* %822, i64 %824
store i8* %825, i8** %42
%826 = load i8**, i8*** %12
%827 = load i8*, i8** %826
%828 = load i32, i32* %18
%829 = mul nsw i32 2, %828
%830 = load i32, i32* %49
%831 = mul nsw i32 %829, %830
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds i8, i8* %827, i64 %832
%834 = load i32, i32* %45
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds i8, i8* %833, i64 %835
store i8* %836, i8** %43
%837 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
store i8* %837, i8** %40
%838 = getelementptr inbounds [10240 x i8], [10240 x i8]* %39, i64 0, i64 0
store i8* %838, i8** %41
br label %839
839: ; preds = %855, %814
%840 = load i8*, i8** %40
%841 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%842 = load i32, i32* %49
%843 = sext i32 %842 to i64
%844 = getelementptr inbounds i8, i8* %841, i64 %843
%845 = icmp ult i8* %840, %844
br i1 %845, label %846, label %860
846: ; preds = %839
%847 = load i8*, i8** %40
%848 = getelementptr inbounds i8, i8* %847, i32 1
store i8* %848, i8** %40
%849 = load i8, i8* %847
%850 = load i8*, i8** %42
store i8 %849, i8* %850
%851 = load i8*, i8** %41
%852 = getelementptr inbounds i8, i8* %851, i32 1
store i8* %852, i8** %41
%853 = load i8, i8* %851
%854 = load i8*, i8** %43
store i8 %853, i8* %854
br label %855
855: ; preds = %846
%856 = load i8*, i8** %42
%857 = getelementptr inbounds i8, i8* %856, i64 2
store i8* %857, i8** %42
%858 = load i8*, i8** %43
%859 = getelementptr inbounds i8, i8* %858, i64 2
store i8* %859, i8** %43
br label %839
860: ; preds = %839
%861 = load i32, i32* %29
%862 = icmp ne i32 %861, 0
br i1 %862, label %863, label %867
863: ; preds = %860
%864 = load i32, i32* %18
%865 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.56, i64 0, i64 0), i32 %864)
%866 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.57, i64 0, i64 0))
br label %867
867: ; preds = %863, %860
%868 = load i32, i32* %46
%869 = sub nsw i32 %868, 2
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 %870
%872 = load i8, i8* %871
%873 = zext i8 %872 to i32
%874 = mul nsw i32 %873, 256
%875 = load i32, i32* %46
%876 = sub nsw i32 %875, 1
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 %877
%879 = load i8, i8* %878
%880 = zext i8 %879 to i32
%881 = add nsw i32 %874, %880
store i32 %881, i32* %46
br label %882
882: ; preds = %867
%883 = load i32, i32* %18
%884 = add nsw i32 %883, 1
store i32 %884, i32* %18
br label %733
885: ; preds = %733
%886 = load i32, i32* %46
%887 = sub nsw i32 %886, 2
store i32 %887, i32* %46
%888 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%889 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %25, i8* %888, i32* %46, i32* %20)
%890 = load i32, i32* %20
%891 = icmp ne i32 %890, 0
br i1 %891, label %892, label %893
892: ; preds = %885
store i32 -2, i32* %20
br label %1018
893: ; preds = %885
%894 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%895 = load i32, i32* %49
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds i8, i8* %894, i64 %896
store i8* %897, i8** %40
%898 = getelementptr inbounds [10240 x i8], [10240 x i8]* %39, i64 0, i64 0
store i8* %898, i8** %41
br label %899
899: ; preds = %936, %893
%900 = load i8*, i8** %40
%901 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%902 = load i32, i32* %46
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds i8, i8* %901, i64 %903
%905 = icmp ult i8* %900, %904
br i1 %905, label %906, label %937
906: ; preds = %899
%907 = load i8*, i8** %40
%908 = getelementptr inbounds i8, i8* %907, i32 1
store i8* %908, i8** %40
%909 = load i8, i8* %907
%910 = zext i8 %909 to i32
store i32 %910, i32* %47
%911 = load i8*, i8** %40
%912 = getelementptr inbounds i8, i8* %911, i32 1
store i8* %912, i8** %40
%913 = load i8, i8* %911
%914 = zext i8 %913 to i32
store i32 %914, i32* %48
%915 = load i32, i32* %29
%916 = icmp ne i32 %915, 0
br i1 %916, label %917, label %923
917: ; preds = %906
br i1 false, label %918, label %923
918: ; preds = %917
%919 = load i32, i32* %18
%920 = load i32, i32* %47
%921 = load i32, i32* %48
%922 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.54, i64 0, i64 0), i32 %919, i32 %920, i32 %921)
br label %923
923: ; preds = %918, %917, %906
store i32 0, i32* %17
br label %924
924: ; preds = %933, %923
%925 = load i32, i32* %17
%926 = load i32, i32* %47
%927 = icmp slt i32 %925, %926
br i1 %927, label %928, label %936
928: ; preds = %924
%929 = load i32, i32* %48
%930 = trunc i32 %929 to i8
%931 = load i8*, i8** %41
%932 = getelementptr inbounds i8, i8* %931, i32 1
store i8* %932, i8** %41
store i8 %930, i8* %931
br label %933
933: ; preds = %928
%934 = load i32, i32* %17
%935 = add nsw i32 %934, 1
store i32 %935, i32* %17
br label %924
936: ; preds = %924
br label %899
937: ; preds = %899
%938 = load i32, i32* %29
%939 = icmp ne i32 %938, 0
br i1 %939, label %940, label %947
940: ; preds = %937
%941 = load i8*, i8** %41
%942 = getelementptr inbounds [10240 x i8], [10240 x i8]* %39, i64 0, i64 0
%943 = ptrtoint i8* %941 to i64
%944 = ptrtoint i8* %942 to i64
%945 = sub i64 %943, %944
%946 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.55, i64 0, i64 0), i64 %945)
br label %947
947: ; preds = %940, %937
%948 = load i8**, i8*** %12
%949 = load i8*, i8** %948
%950 = load i32, i32* %18
%951 = mul nsw i32 2, %950
%952 = load i32, i32* %49
%953 = mul nsw i32 %951, %952
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds i8, i8* %949, i64 %954
%956 = load i32, i32* %44
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds i8, i8* %955, i64 %957
store i8* %958, i8** %42
%959 = load i8**, i8*** %12
%960 = load i8*, i8** %959
%961 = load i32, i32* %18
%962 = mul nsw i32 2, %961
%963 = load i32, i32* %49
%964 = mul nsw i32 %962, %963
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds i8, i8* %960, i64 %965
%967 = load i32, i32* %45
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds i8, i8* %966, i64 %968
store i8* %969, i8** %43
%970 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
store i8* %970, i8** %40
%971 = getelementptr inbounds [10240 x i8], [10240 x i8]* %39, i64 0, i64 0
store i8* %971, i8** %41
br label %972
972: ; preds = %988, %947
%973 = load i8*, i8** %40
%974 = getelementptr inbounds [10240 x i8], [10240 x i8]* %38, i64 0, i64 0
%975 = load i32, i32* %49
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds i8, i8* %974, i64 %976
%978 = icmp ult i8* %973, %977
br i1 %978, label %979, label %993
979: ; preds = %972
%980 = load i8*, i8** %40
%981 = getelementptr inbounds i8, i8* %980, i32 1
store i8* %981, i8** %40
%982 = load i8, i8* %980
%983 = load i8*, i8** %42
store i8 %982, i8* %983
%984 = load i8*, i8** %41
%985 = getelementptr inbounds i8, i8* %984, i32 1
store i8* %985, i8** %41
%986 = load i8, i8* %984
%987 = load i8*, i8** %43
store i8 %986, i8* %987
br label %988
988: ; preds = %979
%989 = load i8*, i8** %42
%990 = getelementptr inbounds i8, i8* %989, i64 2
store i8* %990, i8** %42
%991 = load i8*, i8** %43
%992 = getelementptr inbounds i8, i8* %991, i64 2
store i8* %992, i8** %43
br label %972
993: ; preds = %972
%994 = load i32, i32* %29
%995 = icmp ne i32 %994, 0
br i1 %995, label %996, label %1000
996: ; preds = %993
%997 = load i32, i32* %18
%998 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.56, i64 0, i64 0), i32 %997)
%999 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.58, i64 0, i64 0))
br label %1000
1000: ; preds = %996, %993
%1001 = load i8**, i8*** %10
%1002 = load i8*, i8** %1001
%1003 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @puthd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.35, i64 0, i64 0), i8* %1002)
%1004 = load i32*, i32** %15
store i32 4, i32* %1004
br label %1011
1005: ; preds = %675
%1006 = load i32, i32* %29
%1007 = icmp ne i32 %1006, 0
br i1 %1007, label %1008, label %1010
1008: ; preds = %1005
%1009 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.59, i64 0, i64 0))
br label %1010
1010: ; preds = %1008, %1005
store i32 -4, i32* %20
br label %1018
1011: ; preds = %1000
br label %1012
1012: ; preds = %1011, %674
br label %1013
1013: ; preds = %1012, %615
br label %1014
1014: ; preds = %1013, %557
br label %1015
1015: ; preds = %1014, %495
br label %1016
1016: ; preds = %1015, %436
br label %1017
1017: ; preds = %1016, %361
br label %1018
1018: ; preds = %1017, %1010, %892, %749, %717, %693, %658, %599, %541, %479, %396, %318, %231, %201, %159, %137, %99, %94
%1019 = load i32, i32* %29
%1020 = icmp ne i32 %1019, 0
br i1 %1020, label %1021, label %1023
1021: ; preds = %1018
%1022 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.60, i64 0, i64 0))
br label %1023
1023: ; preds = %1021, %1018
%1024 = load i32, i32* %20
%1025 = icmp ne i32 %1024, 0
br i1 %1025, label %1026, label %1042
1026: ; preds = %1023
%1027 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbcr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %17)
%1028 = load i8**, i8*** %10
%1029 = load i8*, i8** %1028
%1030 = icmp ne i8* %1029, null
br i1 %1030, label %1031, label %1034
1031: ; preds = %1026
%1032 = load i8**, i8*** %10
%1033 = load i8*, i8** %1032
br label %1034
1034: ; preds = %1031, %1026
%1035 = load i8**, i8*** %12
%1036 = load i8*, i8** %1035
%1037 = icmp ne i8* %1036, null
br i1 %1037, label %1038, label %1041
1038: ; preds = %1034
%1039 = load i8**, i8*** %12
%1040 = load i8*, i8** %1039
br label %1041
1041: ; preds = %1038, %1034
br label %1044
1042: ; preds = %1023
%1043 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbcr_ to i32 (i32*, i32*, ...)*)(i32* %25, i32* %20)
br label %1044
1044: ; preds = %1042, %1041
%1045 = load i32, i32* %29
%1046 = icmp ne i32 %1045, 0
br i1 %1046, label %1047, label %1050
1047: ; preds = %1044
%1048 = load i32, i32* %20
%1049 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.61, i64 0, i64 0), i32 %1048)
br label %1050
1050: ; preds = %1047, %1044
%1051 = load i32, i32* %20
store i32 %1051, i32* %8
br label %1052
1052: ; preds = %1050, %74
%1053 = load i32, i32* %8
ret i32 %1053
}

LLVM IR (-O2):
@.str = [18 x i8] c"Opening file: %s\0A\00"
@.str.1 = [33 x i8] c"Error opening file %s, istat=%d\0A\00"
@.str.3 = [29 x i8] c"Read Completion status : %d\0A\00"
@.str.4 = [20 x i8] c"Header length : %d\0A\00"
@.str.5 = [4 x i8] c"DIM\00"
@.str.6 = [3 x i8] c"%d\00"
@.str.8 = [27 x i8] c"Number of dimensions : %d\0A\00"
@.str.9 = [7 x i8] c"SIZE%d\00"
@.str.10 = [18 x i8] c"Error reading %s\0A\00"
@.str.11 = [11 x i8] c"BYTE_ORDER\00"
@.str.12 = [14 x i8] c"little_endian\00"
@.str.13 = [11 x i8] c"big_endian\00"
@.str.14 = [5 x i8] c"TYPE\00"
@.str.15 = [11 x i8] c"Type >%s<\0A\00"
@.str.16 = [16 x i8] c"Image size (%d)\00"
@.str.17 = [5 x i8] c" %d \00"
@.str.19 = [25 x i8] c"Number of elements : %d\0A\00"
@.str.22 = [14 x i8] c"unsigned_byte\00"
@.str.23 = [5 x i8] c"byte\00"
@.str.24 = [14 x i8] c"unsigned_char\00"
@.str.25 = [5 x i8] c"char\00"
@.str.27 = [36 x i8] c"Allocating %d bytes for byte image\0A\00"
@.str.29 = [34 x i8] c"Read Byte Completion status : %d\0A\00"
@.str.30 = [37 x i8] c"Allocating %d bytes for short image\0A\00"
@.str.31 = [36 x i8] c"Converting %d bytes to short image\0A\00"
@.str.35 = [15 x i8] c"unsigned_short\00"
@.str.37 = [21 x i8] c"Allocating %d bytes\0A\00"
@.str.39 = [5 x i8] c"long\00"
@.str.40 = [13 x i8] c"long_integer\00"
@.str.41 = [12 x i8] c"signed_long\00"
@.str.44 = [6 x i8] c"float\00"
@.str.45 = [11 x i8] c"ieee_float\00"
@.str.48 = [13 x i8] c"ieee_complex\00"
@.str.50 = [11 x i8] c"swap_rlmsb\00"
@.str.52 = [18 x i8] c"Reading %d bytes\0A\00"
@.str.53 = [24 x i8] c"Uncompressing %d bytes\0A\00"
@.str.55 = [26 x i8] c"Restored %d bytes in MSB\0A\00"
@.str.56 = [14 x i8] c"Done line %d\0A\00"
@.str.61 = [28 x i8] c"RDSMV completion status %d\0A\00"
@str = [18 x i8] c"Done reading file\00"
@str.62 = [21 x i8] c"Unsupported Filetype\00"
@str.63 = [36 x i8] c"===================================\00"
@str.64 = [34 x i8] c"=================================\00"
@str.65 = [25 x i8] c"Reading compressed image\00"
@str.68 = [22 x i8] c"Reading complex image\00"
@str.71 = [20 x i8] c"Reading float image\00"
@str.73 = [26 x i8] c"Reading signed long image\00"
@str.74 = [19 x i8] c"Reading long image\00"
@str.75 = [15 x i8] c"Swapping bytes\00"
@str.77 = [29 x i8] c"Reading unsigned short image\00"
@str.79 = [18 x i8] c"Reading bit image\00"
@str.80 = [28 x i8] c"Reading unsigned byte image\00"
@str.81 = [19 x i8] c"Reading byte image\00"
@str.82 = [27 x i8] c"Byte order : little_endian\00"
@str.83 = [24 x i8] c"Byte order : big_endian\00"
@str.84 = [25 x i8] c"Error reading dimensions\00"
@str.85 = [15 x i8] c"Reading header\00"
define i32 @rdsmv(i8* %0, i8** nocapture %1, i32* nocapture writeonly %2, i8** nocapture %3, i32* nocapture writeonly %4, i32* %5, i32* nocapture writeonly %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [80 x i8]
%15 = alloca [80 x i8]
%16 = alloca i32
%17 = alloca i32
%18 = alloca [10240 x i8]
%19 = alloca [10240 x i8]
%20 = alloca i32
%21 = bitcast i32* %8 to i8*
%22 = bitcast i32* %9 to i8*
%23 = bitcast i32* %10 to i8*
%24 = bitcast i32* %11 to i8*
%25 = bitcast i32* %12 to i8*
%26 = bitcast i32* %13 to i8*
%27 = getelementptr inbounds [80 x i8], [80 x i8]* %14, i64 0, i64 0
%28 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 0
%29 = bitcast i32* %16 to i8*
store i32 1, i32* %16
%30 = bitcast i32* %17 to i8*
%31 = tail call i32 (...) @filec_getdebug()
store i8* null, i8** %1
store i8* null, i8** %3
%32 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%33 = trunc i64 %32 to i32
store i32 %33, i32* %10
%34 = icmp eq i32 %31, 0
br i1 %34, label %35, label %39
35: ; preds = %7
%36 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbor_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %0, i32* %10, i32* %12)
%37 = load i32, i32* %12
%38 = icmp eq i32 %37, 0
br i1 %38, label %46, label %824
39: ; preds = %7
%40 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %0)
%41 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbor_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %0, i32* %10, i32* %12)
%42 = load i32, i32* %12
%43 = icmp eq i32 %42, 0
br i1 %43, label %46, label %44
44: ; preds = %39
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i8* %0, i32 %42)
br label %824
46: ; preds = %39, %35
store i32 1, i32* %17
%47 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
store i32 512, i32* %8
%48 = call dereferenceable_or_null(512) i8* @calloc(i64 1, i64 512)
br i1 %34, label %54, label %49
49: ; preds = %46
%50 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.85, i64 0, i64 0))
%51 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %48, i32* %8, i32* %12)
%52 = load i32, i32* %12
%53 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %52)
br label %56
54: ; preds = %46
%55 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %48, i32* %8, i32* %12)
br label %56
56: ; preds = %54, %49
%57 = load i32, i32* %12
%58 = icmp eq i32 %57, 0
br i1 %58, label %60, label %59
59: ; preds = %56
store i32 -2, i32* %12
br label %801
60: ; preds = %56
%61 = call i32 (i32*, i8*, ...) bitcast (i32 (...)* @gethdl to i32 (i32*, i8*, ...)*)(i32* %11, i8* %48)
store i32 %61, i32* %12
%62 = icmp slt i32 %61, 0
br i1 %62, label %63, label %64
63: ; preds = %60
store i32 -4, i32* %12
br label %801
64: ; preds = %60
br i1 %34, label %68, label %65
65: ; preds = %64
%66 = load i32, i32* %11
%67 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0), i32 %66)
br label %68
68: ; preds = %65, %64
%69 = load i32, i32* %11
%70 = sdiv i32 %69, 1024
%71 = shl nsw i32 %70, 10
%72 = add i32 %71, 1024
store i32 %72, i32* %2
%73 = sext i32 %72 to i64
%74 = call i8* @malloc(i64 %73)
store i8* %74, i8** %1
%75 = icmp eq i32 %72, 0
%76 = add nsw i64 %73, -512
%77 = select i1 %75, i64 0, i64 %76
%78 = getelementptr i8, i8* %74, i64 512
%79 = add nsw i32 %69, -512
store i32 %79, i32* %8
%80 = icmp sgt i32 %69, 512
br i1 %80, label %81, label %87
81: ; preds = %68
%82 = getelementptr inbounds i8, i8* %74, i64 512
%83 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %82, i32* %8, i32* %12)
%84 = load i32, i32* %12
%85 = icmp eq i32 %84, 0
br i1 %85, label %87, label %86
86: ; preds = %81
store i32 -2, i32* %12
br label %801
87: ; preds = %81, %68
store i32 0, i32* %17
%88 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
store i32 0, i32* %4
%89 = load i8*, i8** %1
%90 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i8* %27, i8* %89)
%91 = load i8, i8* %27
%92 = icmp eq i8 %91, 0
br i1 %92, label %96, label %93
93: ; preds = %87
%94 = call i32 (i8*, i8*, ...) @sscanf(i8* %27, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %13)
%95 = icmp eq i32 %94, 1
br i1 %95, label %99, label %96
96: ; preds = %93, %87
br i1 %34, label %804, label %97
97: ; preds = %96
%98 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.84, i64 0, i64 0))
br label %802
99: ; preds = %93
br i1 %34, label %103, label %100
100: ; preds = %99
%101 = load i32, i32* %13
%102 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.8, i64 0, i64 0), i32 %101)
br label %103
103: ; preds = %100, %99
%104 = load i32, i32* %13
store i32 %104, i32* %4
store i32 0, i32* %9
%105 = icmp sgt i32 %104, 0
br i1 %105, label %106, label %128
106: ; preds = %103, %123
%107 = phi i32 [ %125, %123 ], [ 1, %103 ]
%108 = phi i32 [ %109, %123 ], [ 0, %103 ]
%109 = add nuw nsw i32 %108, 1
%110 = call i32 (i8*, i8*, ...) @sprintf(i8* %28, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i32 %109)
%111 = load i8*, i8** %1
%112 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* %28, i8* %27, i8* %111)
%113 = load i8, i8* %27
%114 = icmp eq i8 %113, 0
br i1 %114, label %120, label %115
115: ; preds = %106
%116 = zext i32 %108 to i64
%117 = getelementptr inbounds i32, i32* %5, i64 %116
%118 = call i32 (i8*, i8*, ...) @sscanf(i8* %27, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0), i32* %117)
%119 = icmp eq i32 %118, 1
br i1 %119, label %123, label %120
120: ; preds = %115, %106
br i1 %34, label %804, label %121
121: ; preds = %120
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0), i8* %28)
br label %802
123: ; preds = %115
%124 = load i32, i32* %117
%125 = mul nsw i32 %124, %107
store i32 %109, i32* %9
%126 = load i32, i32* %13
%127 = icmp slt i32 %109, %126
br i1 %127, label %106, label %128
128: ; preds = %123, %103
%129 = phi i32 [ 1, %103 ], [ %125, %123 ]
%130 = load i8*, i8** %1
%131 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i64 0, i64 0), i8* %27, i8* %130)
%132 = load i8, i8* %27
%133 = icmp eq i8 %132, 0
br i1 %133, label %141, label %134
134: ; preds = %128
%135 = call i32 @bcmp(i8* dereferenceable(14) %27, i8* dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0), i64 14)
%136 = icmp eq i32 %135, 0
br i1 %136, label %141, label %137
137: ; preds = %134
%138 = call i32 @bcmp(i8* dereferenceable(11) %27, i8* dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0), i64 11)
%139 = icmp eq i32 %138, 0
br i1 %139, label %141, label %140
140: ; preds = %137
store i32 -4, i32* %12
br label %801
141: ; preds = %128, %137, %134
%142 = phi i8* [ getelementptr inbounds ([27 x i8], [27 x i8]* @str.82, i64 0, i64 0), %134 ], [ getelementptr inbounds ([24 x i8], [24 x i8]* @str.83, i64 0, i64 0), %137 ], [ getelementptr inbounds ([24 x i8], [24 x i8]* @str.83, i64 0, i64 0), %128 ]
%143 = phi i32 [ 0, %134 ], [ 1, %137 ], [ -1, %128 ]
%144 = load i8*, i8** %1
%145 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @gethd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), i8* %27, i8* %144)
br i1 %34, label %165, label %146
146: ; preds = %141
%147 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), i8* %27)
%148 = load i32, i32* %13
%149 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0), i32 %148)
store i32 0, i32* %9
%150 = load i32, i32* %13
%151 = icmp sgt i32 %150, 0
br i1 %151, label %152, label %161
152: ; preds = %146, %152
%153 = phi i32 [ %158, %152 ], [ 0, %146 ]
%154 = zext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %5, i64 %154
%156 = load i32, i32* %155
%157 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0), i32 %156)
%158 = add nuw nsw i32 %153, 1
store i32 %158, i32* %9
%159 = load i32, i32* %13
%160 = icmp slt i32 %158, %159
br i1 %160, label %152, label %161
161: ; preds = %152, %146
%162 = call i32 @putchar(i32 10)
%163 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.19, i64 0, i64 0), i32 %129)
%164 = call i32 @puts(i8* dereferenceable(1) %142)
br label %165
165: ; preds = %161, %141
%166 = call i32 @bcmp(i8* dereferenceable(14) %27, i8* dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.22, i64 0, i64 0), i64 14)
%167 = icmp eq i32 %166, 0
br i1 %167, label %177, label %168
168: ; preds = %165
%169 = call i32 @bcmp(i8* dereferenceable(5) %27, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i64 0, i64 0), i64 5)
%170 = icmp eq i32 %169, 0
br i1 %170, label %177, label %171
171: ; preds = %168
%172 = call i32 @bcmp(i8* dereferenceable(14) %27, i8* dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.24, i64 0, i64 0), i64 14)
%173 = icmp eq i32 %172, 0
br i1 %173, label %177, label %174
174: ; preds = %171
%175 = call i32 @bcmp(i8* dereferenceable(5) %27, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.25, i64 0, i64 0), i64 5)
%176 = icmp eq i32 %175, 0
br i1 %176, label %177, label %291
177: ; preds = %174, %171, %168, %165
br i1 %34, label %187, label %178
178: ; preds = %177
%179 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.81, i64 0, i64 0))
%180 = sext i32 %129 to i64
store i32 %129, i32* %8
%181 = call i8* @malloc(i64 %180)
%182 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.27, i64 0, i64 0), i32 %129)
%183 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.80, i64 0, i64 0))
%184 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %181, i32* %8, i32* %12)
%185 = load i32, i32* %12
%186 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.29, i64 0, i64 0), i32 %185)
br label %191
187: ; preds = %177
%188 = sext i32 %129 to i64
store i32 %129, i32* %8
%189 = call i8* @malloc(i64 %188)
%190 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %189, i32* %8, i32* %12)
br label %191
191: ; preds = %187, %178
%192 = phi i8* [ %189, %187 ], [ %181, %178 ]
%193 = phi i64 [ %188, %187 ], [ %180, %178 ]
%194 = load i32, i32* %12
%195 = icmp eq i32 %194, 0
br i1 %195, label %197, label %196
196: ; preds = %191
store i32 -2, i32* %12
br label %801
197: ; preds = %191
store i32 1, i32* %17
%198 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
br i1 %34, label %202, label %199
199: ; preds = %197
%200 = shl i32 %129, 1
store i32 %200, i32* %8
%201 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.30, i64 0, i64 0), i32 %200)
br label %202
202: ; preds = %199, %197
%203 = shl nsw i64 %193, 1
%204 = call i8* @malloc(i64 %203)
store i8* %204, i8** %3
store i32 4, i32* %6
%205 = bitcast i8* %204 to i16*
br i1 %34, label %208, label %206
206: ; preds = %202
%207 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.31, i64 0, i64 0), i32 %129)
br label %208
208: ; preds = %206, %202
%209 = icmp sgt i32 %129, 0
br i1 %209, label %210, label %290
210: ; preds = %208
%211 = add i32 %129, -1
%212 = zext i32 %211 to i64
%213 = add nuw nsw i64 %212, 1
%214 = icmp ult i32 %211, 15
br i1 %214, label %276, label %215
215: ; preds = %210
%216 = and i64 %213, 8589934576
%217 = getelementptr i16, i16* %205, i64 %216
%218 = getelementptr i8, i8* %192, i64 %216
%219 = trunc i64 %216 to i32
%220 = add nsw i64 %216, -16
%221 = lshr exact i64 %220, 4
%222 = add nuw nsw i64 %221, 1
%223 = and i64 %222, 1
%224 = icmp eq i64 %220, 0
br i1 %224, label %258, label %225
225: ; preds = %215
%226 = and i64 %222, 2305843009213693950
br label %227
227: ; preds = %227, %225
%228 = phi i64 [ 0, %225 ], [ %255, %227 ]
%229 = phi i64 [ 0, %225 ], [ %256, %227 ]
%230 = getelementptr i16, i16* %205, i64 %228
%231 = getelementptr i8, i8* %192, i64 %228
%232 = bitcast i8* %231 to <8 x i8>*
%233 = load <8 x i8>, <8 x i8>* %232
%234 = getelementptr i8, i8* %231, i64 8
%235 = bitcast i8* %234 to <8 x i8>*
%236 = load <8 x i8>, <8 x i8>* %235
%237 = zext <8 x i8> %233 to <8 x i16>
%238 = zext <8 x i8> %236 to <8 x i16>
%239 = bitcast i16* %230 to <8 x i16>*
store <8 x i16> %237, <8 x i16>* %239
%240 = getelementptr i16, i16* %230, i64 8
%241 = bitcast i16* %240 to <8 x i16>*
store <8 x i16> %238, <8 x i16>* %241
%242 = or i64 %228, 16
%243 = getelementptr i16, i16* %205, i64 %242
%244 = getelementptr i8, i8* %192, i64 %242
%245 = bitcast i8* %244 to <8 x i8>*
%246 = load <8 x i8>, <8 x i8>* %245
%247 = getelementptr i8, i8* %244, i64 8
%248 = bitcast i8* %247 to <8 x i8>*
%249 = load <8 x i8>, <8 x i8>* %248
%250 = zext <8 x i8> %246 to <8 x i16>
%251 = zext <8 x i8> %249 to <8 x i16>
%252 = bitcast i16* %243 to <8 x i16>*
store <8 x i16> %250, <8 x i16>* %252
%253 = getelementptr i16, i16* %243, i64 8
%254 = bitcast i16* %253 to <8 x i16>*
store <8 x i16> %251, <8 x i16>* %254
%255 = add nuw i64 %228, 32
%256 = add i64 %229, 2
%257 = icmp eq i64 %256, %226
br i1 %257, label %258, label %227
258: ; preds = %227, %215
%259 = phi i64 [ 0, %215 ], [ %255, %227 ]
%260 = icmp eq i64 %223, 0
br i1 %260, label %274, label %261
261: ; preds = %258
%262 = getelementptr i16, i16* %205, i64 %259
%263 = getelementptr i8, i8* %192, i64 %259
%264 = bitcast i8* %263 to <8 x i8>*
%265 = load <8 x i8>, <8 x i8>* %264
%266 = getelementptr i8, i8* %263, i64 8
%267 = bitcast i8* %266 to <8 x i8>*
%268 = load <8 x i8>, <8 x i8>* %267
%269 = zext <8 x i8> %265 to <8 x i16>
%270 = zext <8 x i8> %268 to <8 x i16>
%271 = bitcast i16* %262 to <8 x i16>*
store <8 x i16> %269, <8 x i16>* %271
%272 = getelementptr i16, i16* %262, i64 8
%273 = bitcast i16* %272 to <8 x i16>*
store <8 x i16> %270, <8 x i16>* %273
br label %274
274: ; preds = %258, %261
%275 = icmp eq i64 %213, %216
br i1 %275, label %290, label %276
276: ; preds = %210, %274
%277 = phi i16* [ %205, %210 ], [ %217, %274 ]
%278 = phi i8* [ %192, %210 ], [ %218, %274 ]
%279 = phi i32 [ 0, %210 ], [ %219, %274 ]
br label %280
280: ; preds = %276, %280
%281 = phi i16* [ %287, %280 ], [ %277, %276 ]
%282 = phi i8* [ %284, %280 ], [ %278, %276 ]
%283 = phi i32 [ %288, %280 ], [ %279, %276 ]
%284 = getelementptr inbounds i8, i8* %282, i64 1
%285 = load i8, i8* %282
%286 = zext i8 %285 to i16
%287 = getelementptr inbounds i16, i16* %281, i64 1
store i16 %286, i16* %281
%288 = add nuw nsw i32 %283, 1
%289 = icmp eq i32 %288, %129
br i1 %289, label %290, label %280
290: ; preds = %280, %274, %208
br label %801
291: ; preds = %174
%292 = bitcast [80 x i8]* %14 to i32*
%293 = load i32, i32* %292
switch i32 %293, label %417 [
i32 7629154, label %294
i32 6578541, label %420
]
294: ; preds = %291
br i1 %34, label %297, label %295
295: ; preds = %294
%296 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.79, i64 0, i64 0))
br label %297
297: ; preds = %295, %294
%298 = sext i32 %129 to i64
%299 = ashr i32 %129, 3
store i32 %299, i32* %8
%300 = sext i32 %299 to i64
%301 = call i8* @malloc(i64 %300)
br i1 %34, label %307, label %302
302: ; preds = %297
%303 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.79, i64 0, i64 0))
%304 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %301, i32* %8, i32* %12)
%305 = load i32, i32* %12
%306 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %305)
br label %309
307: ; preds = %297
%308 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %301, i32* %8, i32* %12)
br label %309
309: ; preds = %307, %302
%310 = load i32, i32* %12
%311 = icmp eq i32 %310, 0
br i1 %311, label %313, label %312
312: ; preds = %309
store i32 -2, i32* %12
br label %801
313: ; preds = %309
store i32 1, i32* %17
%314 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
%315 = shl nsw i64 %298, 1
%316 = call i8* @malloc(i64 %315)
store i8* %316, i8** %3
store i32 4, i32* %6
%317 = icmp sgt i32 %129, 0
br i1 %317, label %318, label %416
318: ; preds = %313
%319 = bitcast i8* %316 to i16*
%320 = add i32 %129, -1
%321 = lshr i32 %320, 3
%322 = add nuw nsw i32 %321, 1
%323 = zext i32 %322 to i64
%324 = icmp ult i32 %320, 56
br i1 %324, label %379, label %325
325: ; preds = %318
%326 = add i32 %129, -1
%327 = lshr i32 %326, 3
%328 = zext i32 %327 to i64
%329 = shl nuw nsw i64 %328, 4
%330 = add nuw nsw i64 %329, 16
%331 = getelementptr i8, i8* %316, i64 %330
%332 = add nuw nsw i64 %328, 1
%333 = getelementptr i8, i8* %301, i64 %332
%334 = icmp ult i8* %316, %333
%335 = icmp ult i8* %301, %331
%336 = and i1 %334, %335
br i1 %336, label %379, label %337
337: ; preds = %325
%338 = and i64 %323, 1073741816
%339 = shl nuw nsw i64 %338, 3
%340 = getelementptr i16, i16* %319, i64 %339
%341 = getelementptr i8, i8* %301, i64 %338
%342 = trunc i64 %338 to i32
%343 = shl i32 %342, 3
br label %344
344: ; preds = %344, %337
%345 = phi i64 [ 0, %337 ], [ %375, %344 ]
%346 = shl i64 %345, 3
%347 = getelementptr i8, i8* %301, i64 %345
%348 = bitcast i8* %347 to <8 x i8>*
%349 = load <8 x i8>, <8 x i8>* %348
%350 = and <8 x i8> %349, <i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2>
%351 = zext <8 x i8> %350 to <8 x i16>
%352 = and <8 x i8> %349, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%353 = zext <8 x i8> %352 to <8 x i16>
%354 = and <8 x i8> %349, <i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8, i8 8>
%355 = zext <8 x i8> %354 to <8 x i16>
%356 = and <8 x i8> %349, <i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16, i8 16>
%357 = zext <8 x i8> %356 to <8 x i16>
%358 = bitcast i8* %347 to <8 x i8>*
%359 = load <8 x i8>, <8 x i8>* %358
%360 = and <8 x i8> %359, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%361 = zext <8 x i8> %360 to <8 x i16>
%362 = and <8 x i8> %359, <i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64, i8 64>
%363 = zext <8 x i8> %362 to <8 x i16>
%364 = and <8 x i8> %359, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%365 = zext <8 x i8> %364 to <8 x i16>
%366 = getelementptr inbounds i16, i16* %319, i64 %346
%367 = bitcast i16* %366 to <64 x i16>*
%368 = shufflevector <8 x i16> %351, <8 x i16> %353, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%369 = shufflevector <8 x i16> %355, <8 x i16> %357, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%370 = shufflevector <8 x i16> %361, <8 x i16> %363, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%371 = shufflevector <8 x i16> %365, <8 x i16> zeroinitializer, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%372 = shufflevector <16 x i16> %368, <16 x i16> %369, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
%373 = shufflevector <16 x i16> %370, <16 x i16> %371, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
%374 = shufflevector <32 x i16> %372, <32 x i16> %373, <64 x i32> <i32 0, i32 8, i32 16, i32 24, i32 32, i32 40, i32 48, i32 56, i32 1, i32 9, i32 17, i32 25, i32 33, i32 41, i32 49, i32 57, i32 2, i32 10, i32 18, i32 26, i32 34, i32 42, i32 50, i32 58, i32 3, i32 11, i32 19, i32 27, i32 35, i32 43, i32 51, i32 59, i32 4, i32 12, i32 20, i32 28, i32 36, i32 44, i32 52, i32 60, i32 5, i32 13, i32 21, i32 29, i32 37, i32 45, i32 53, i32 61, i32 6, i32 14, i32 22, i32 30, i32 38, i32 46, i32 54, i32 62, i32 7, i32 15, i32 23, i32 31, i32 39, i32 47, i32 55, i32 63>
store <64 x i16> %374, <64 x i16>* %367
%375 = add nuw i64 %345, 8
%376 = icmp eq i64 %375, %338
br i1 %376, label %377, label %344
377: ; preds = %344
%378 = icmp eq i64 %338, %323
br i1 %378, label %415, label %379
379: ; preds = %325, %318, %377
%380 = phi i16* [ %319, %325 ], [ %319, %318 ], [ %340, %377 ]
%381 = phi i8* [ %301, %325 ], [ %301, %318 ], [ %341, %377 ]
%382 = phi i32 [ 0, %325 ], [ 0, %318 ], [ %343, %377 ]
br label %383
383: ; preds = %379, %383
%384 = phi i16* [ %411, %383 ], [ %380, %379 ]
%385 = phi i8* [ %412, %383 ], [ %381, %379 ]
%386 = phi i32 [ %413, %383 ], [ %382, %379 ]
%387 = load i8, i8* %385
%388 = and i8 %387, 2
%389 = zext i8 %388 to i16
%390 = getelementptr inbounds i16, i16* %384, i64 1
store i16 %389, i16* %384
%391 = and i8 %387, 4
%392 = zext i8 %391 to i16
%393 = getelementptr inbounds i16, i16* %384, i64 2
store i16 %392, i16* %390
%394 = and i8 %387, 8
%395 = zext i8 %394 to i16
%396 = getelementptr inbounds i16, i16* %384, i64 3
store i16 %395, i16* %393
%397 = and i8 %387, 16
%398 = zext i8 %397 to i16
%399 = getelementptr inbounds i16, i16* %384, i64 4
store i16 %398, i16* %396
%400 = load i8, i8* %385
%401 = and i8 %400, 32
%402 = zext i8 %401 to i16
%403 = getelementptr inbounds i16, i16* %384, i64 5
store i16 %402, i16* %399
%404 = and i8 %400, 64
%405 = zext i8 %404 to i16
%406 = getelementptr inbounds i16, i16* %384, i64 6
store i16 %405, i16* %403
%407 = load i8, i8* %385
%408 = and i8 %407, -128
%409 = zext i8 %408 to i16
%410 = getelementptr inbounds i16, i16* %384, i64 7
store i16 %409, i16* %406
%411 = getelementptr inbounds i16, i16* %384, i64 8
store i16 0, i16* %410
%412 = getelementptr inbounds i8, i8* %385, i64 1
%413 = add nuw nsw i32 %386, 8
%414 = icmp slt i32 %413, %129
br i1 %414, label %383, label %415
415: ; preds = %383, %377
store i32 8, i32* %10
br label %416
416: ; preds = %415, %313
br label %801
417: ; preds = %291
%418 = call i32 @bcmp(i8* dereferenceable(15) %27, i8* dereferenceable(15) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.35, i64 0, i64 0), i64 15)
%419 = icmp eq i32 %418, 0
br i1 %419, label %420, label %453
420: ; preds = %291, %417
br i1 %34, label %428, label %421
421: ; preds = %420
%422 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.77, i64 0, i64 0))
%423 = shl i32 %129, 1
store i32 %423, i32* %8
%424 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.77, i64 0, i64 0))
%425 = load i32, i32* %8
%426 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %425)
%427 = load i32, i32* %8
br label %430
428: ; preds = %420
%429 = shl i32 %129, 1
store i32 %429, i32* %8
br label %430
430: ; preds = %428, %421
%431 = phi i32 [ %429, %428 ], [ %427, %421 ]
%432 = sext i32 %431 to i64
%433 = call i8* @malloc(i64 %432)
store i8* %433, i8** %3
store i32 4, i32* %6
%434 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %433, i32* %8, i32* %12)
br i1 %34, label %438, label %435
435: ; preds = %430
%436 = load i32, i32* %12
%437 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %436)
br label %438
438: ; preds = %435, %430
%439 = load i32, i32* %12
%440 = icmp eq i32 %439, 0
br i1 %440, label %442, label %441
441: ; preds = %438
store i32 -2, i32* %12
br label %801
442: ; preds = %438
store i32 1, i32* %17
%443 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
%444 = call i32 (...) @getbo()
%445 = icmp eq i32 %143, %444
br i1 %445, label %801, label %446
446: ; preds = %442
br i1 %34, label %449, label %447
447: ; preds = %446
%448 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.75, i64 0, i64 0))
br label %449
449: ; preds = %447, %446
%450 = load i32, i32* %8
%451 = load i8*, i8** %3
%452 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 0, i32 %450, i8* %451)
br label %801
453: ; preds = %417
%454 = call i32 @bcmp(i8* dereferenceable(5) %27, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0), i64 5)
%455 = icmp eq i32 %454, 0
br i1 %455, label %462, label %456
456: ; preds = %453
%457 = call i32 @bcmp(i8* dereferenceable(13) %27, i8* dereferenceable(13) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.40, i64 0, i64 0), i64 13)
%458 = icmp eq i32 %457, 0
br i1 %458, label %462, label %459
459: ; preds = %456
%460 = call i32 @bcmp(i8* dereferenceable(12) %27, i8* dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0), i64 12)
%461 = icmp eq i32 %460, 0
br i1 %461, label %462, label %495
462: ; preds = %459, %456, %453
br i1 %34, label %470, label %463
463: ; preds = %462
%464 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.74, i64 0, i64 0))
%465 = shl i32 %129, 2
store i32 %465, i32* %8
%466 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.73, i64 0, i64 0))
%467 = load i32, i32* %8
%468 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %467)
%469 = load i32, i32* %8
br label %472
470: ; preds = %462
%471 = shl i32 %129, 2
store i32 %471, i32* %8
br label %472
472: ; preds = %470, %463
%473 = phi i32 [ %471, %470 ], [ %469, %463 ]
%474 = sext i32 %473 to i64
%475 = call i8* @malloc(i64 %474)
store i8* %475, i8** %3
store i32 5, i32* %6
%476 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %475, i32* %8, i32* %12)
br i1 %34, label %480, label %477
477: ; preds = %472
%478 = load i32, i32* %12
%479 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %478)
br label %480
480: ; preds = %477, %472
%481 = load i32, i32* %12
%482 = icmp eq i32 %481, 0
br i1 %482, label %484, label %483
483: ; preds = %480
store i32 -2, i32* %12
br label %801
484: ; preds = %480
store i32 1, i32* %17
%485 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
%486 = call i32 (...) @getbo()
%487 = icmp eq i32 %143, %486
br i1 %487, label %801, label %488
488: ; preds = %484
br i1 %34, label %491, label %489
489: ; preds = %488
%490 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.75, i64 0, i64 0))
br label %491
491: ; preds = %489, %488
%492 = load i32, i32* %8
%493 = load i8*, i8** %3
%494 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 1, i32 %492, i8* %493)
br label %801
495: ; preds = %459
%496 = call i32 @bcmp(i8* dereferenceable(6) %27, i8* dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.44, i64 0, i64 0), i64 6)
%497 = icmp eq i32 %496, 0
br i1 %497, label %501, label %498
498: ; preds = %495
%499 = call i32 @bcmp(i8* dereferenceable(11) %27, i8* dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.45, i64 0, i64 0), i64 11)
%500 = icmp eq i32 %499, 0
br i1 %500, label %501, label %534
501: ; preds = %498, %495
br i1 %34, label %509, label %502
502: ; preds = %501
%503 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.71, i64 0, i64 0))
%504 = shl i32 %129, 2
store i32 %504, i32* %8
%505 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.71, i64 0, i64 0))
%506 = load i32, i32* %8
%507 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %506)
%508 = load i32, i32* %8
br label %511
509: ; preds = %501
%510 = shl i32 %129, 2
store i32 %510, i32* %8
br label %511
511: ; preds = %509, %502
%512 = phi i32 [ %510, %509 ], [ %508, %502 ]
%513 = sext i32 %512 to i64
%514 = call i8* @malloc(i64 %513)
store i8* %514, i8** %3
store i32 7, i32* %6
%515 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %514, i32* %8, i32* %12)
br i1 %34, label %519, label %516
516: ; preds = %511
%517 = load i32, i32* %12
%518 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %517)
br label %519
519: ; preds = %516, %511
%520 = load i32, i32* %12
%521 = icmp eq i32 %520, 0
br i1 %521, label %523, label %522
522: ; preds = %519
store i32 -2, i32* %12
br label %801
523: ; preds = %519
store i32 1, i32* %17
%524 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
%525 = call i32 (...) @getbo()
%526 = icmp eq i32 %143, %525
br i1 %526, label %801, label %527
527: ; preds = %523
br i1 %34, label %530, label %528
528: ; preds = %527
%529 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.75, i64 0, i64 0))
br label %530
530: ; preds = %528, %527
%531 = load i32, i32* %8
%532 = load i8*, i8** %3
%533 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 1, i32 %531, i8* %532)
br label %801
534: ; preds = %498
%535 = bitcast [80 x i8]* %14 to i64*
%536 = load i64, i64* %535
%537 = icmp eq i64 %536, 33888513622372195
br i1 %537, label %541, label %538
538: ; preds = %534
%539 = call i32 @bcmp(i8* dereferenceable(13) %27, i8* dereferenceable(13) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.48, i64 0, i64 0), i64 13)
%540 = icmp eq i32 %539, 0
br i1 %540, label %541, label %574
541: ; preds = %538, %534
br i1 %34, label %549, label %542
542: ; preds = %541
%543 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.68, i64 0, i64 0))
%544 = shl i32 %129, 3
store i32 %544, i32* %8
%545 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.68, i64 0, i64 0))
%546 = load i32, i32* %8
%547 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %546)
%548 = load i32, i32* %8
br label %551
549: ; preds = %541
%550 = shl i32 %129, 3
store i32 %550, i32* %8
br label %551
551: ; preds = %549, %542
%552 = phi i32 [ %550, %549 ], [ %548, %542 ]
%553 = sext i32 %552 to i64
%554 = call i8* @malloc(i64 %553)
store i8* %554, i8** %3
store i32 9, i32* %6
%555 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %554, i32* %8, i32* %12)
br i1 %34, label %559, label %556
556: ; preds = %551
%557 = load i32, i32* %12
%558 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %557)
br label %559
559: ; preds = %556, %551
%560 = load i32, i32* %12
%561 = icmp eq i32 %560, 0
br i1 %561, label %563, label %562
562: ; preds = %559
store i32 -2, i32* %12
br label %801
563: ; preds = %559
store i32 1, i32* %17
%564 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbwr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %17)
%565 = call i32 (...) @getbo()
%566 = icmp eq i32 %143, %565
br i1 %566, label %801, label %567
567: ; preds = %563
br i1 %34, label %570, label %568
568: ; preds = %567
%569 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.75, i64 0, i64 0))
br label %570
570: ; preds = %568, %567
%571 = load i32, i32* %8
%572 = load i8*, i8** %3
%573 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @swpbyt to i32 (i32, i32, i8*, ...)*)(i32 1, i32 %571, i8* %572)
br label %801
574: ; preds = %538
%575 = call i32 @bcmp(i8* dereferenceable(11) %27, i8* dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.50, i64 0, i64 0), i64 11)
%576 = icmp eq i32 %575, 0
br i1 %576, label %577, label %797
577: ; preds = %574
%578 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 0
%579 = getelementptr inbounds [10240 x i8], [10240 x i8]* %19, i64 0, i64 0
%580 = bitcast i32* %20 to i8*
%581 = load i32, i32* %5
%582 = getelementptr inbounds i32, i32* %5, i64 1
%583 = load i32, i32* %582
br i1 %34, label %586, label %584
584: ; preds = %577
%585 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.65, i64 0, i64 0))
br label %586
586: ; preds = %584, %577
%587 = load i32, i32* %13
%588 = icmp eq i32 %587, 2
br i1 %588, label %589, label %796
589: ; preds = %586
%590 = shl i32 %129, 1
store i32 %590, i32* %8
%591 = sext i32 %590 to i64
%592 = call i8* @malloc(i64 %591)
store i8* %592, i8** %3
%593 = call i32 (...) @getbo()
switch i32 %593, label %595 [
i32 0, label %596
i32 1, label %594
]
594: ; preds = %589
br label %596
595: ; preds = %589
br label %596
596: ; preds = %589, %595, %594
%597 = phi i64 [ 1, %594 ], [ 0, %589 ], [ 0, %595 ]
%598 = phi i64 [ 0, %594 ], [ 1, %589 ], [ 0, %595 ]
store i32 2, i32* %20
%599 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %578, i32* %20, i32* %12)
%600 = load i32, i32* %12
%601 = icmp eq i32 %600, 0
br i1 %601, label %603, label %602
602: ; preds = %596
store i32 -2, i32* %12
br label %796
603: ; preds = %596
%604 = load i32, i32* %20
%605 = add nsw i32 %604, -2
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %606
%608 = load i8, i8* %607
%609 = zext i8 %608 to i32
%610 = shl nuw nsw i32 %609, 8
%611 = add nsw i32 %604, -1
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %612
%614 = load i8, i8* %613
%615 = zext i8 %614 to i32
%616 = or i32 %610, %615
store i32 %616, i32* %20
%617 = add nsw i32 %583, -1
store i32 0, i32* %10
%618 = icmp sgt i32 %583, 1
br i1 %618, label %619, label %722
619: ; preds = %603
%620 = sub i32 -2, %581
%621 = sext i32 %581 to i64
%622 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %621
%623 = ptrtoint [10240 x i8]* %19 to i64
%624 = shl i32 %581, 1
%625 = icmp sgt i32 %581, 0
br label %626
626: ; preds = %619, %705
%627 = phi i32 [ %616, %619 ], [ %718, %705 ]
br i1 %34, label %628, label %632
628: ; preds = %626
%629 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %578, i32* %20, i32* %12)
%630 = load i32, i32* %12
%631 = icmp eq i32 %630, 0
br i1 %631, label %642, label %637
632: ; preds = %626
%633 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.52, i64 0, i64 0), i32 %627)
%634 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %578, i32* %20, i32* %12)
%635 = load i32, i32* %12
%636 = icmp eq i32 %635, 0
br i1 %636, label %638, label %637
637: ; preds = %632, %628
store i32 -2, i32* %12
br label %796
638: ; preds = %632
%639 = load i32, i32* %20
%640 = add i32 %620, %639
%641 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.53, i64 0, i64 0), i32 %640)
br label %642
642: ; preds = %628, %638
%643 = load i32, i32* %20
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %644
%646 = getelementptr inbounds i8, i8* %645, i64 -2
%647 = icmp ult i8* %622, %646
br i1 %647, label %657, label %673
648: ; preds = %667
%649 = load i32, i32* %20
br label %650
650: ; preds = %648, %657
%651 = phi i32 [ %658, %657 ], [ %649, %648 ]
%652 = phi i8* [ %659, %657 ], [ %669, %648 ]
%653 = sext i32 %651 to i64
%654 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %653
%655 = getelementptr inbounds i8, i8* %654, i64 -2
%656 = icmp ult i8* %664, %655
br i1 %656, label %657, label %673
657: ; preds = %642, %650
%658 = phi i32 [ %651, %650 ], [ %643, %642 ]
%659 = phi i8* [ %652, %650 ], [ %579, %642 ]
%660 = phi i8* [ %664, %650 ], [ %622, %642 ]
%661 = getelementptr inbounds i8, i8* %660, i64 1
%662 = load i8, i8* %660
%663 = zext i8 %662 to i32
%664 = getelementptr inbounds i8, i8* %660, i64 2
%665 = load i8, i8* %661
store i32 0, i32* %9
%666 = icmp eq i8 %662, 0
br i1 %666, label %650, label %667
667: ; preds = %657, %667
%668 = phi i8* [ %669, %667 ], [ %659, %657 ]
%669 = getelementptr inbounds i8, i8* %668, i64 1
store i8 %665, i8* %668
%670 = load i32, i32* %9
%671 = add nsw i32 %670, 1
store i32 %671, i32* %9
%672 = icmp slt i32 %671, %663
br i1 %672, label %667, label %648
673: ; preds = %650, %642
%674 = phi i8* [ %579, %642 ], [ %652, %650 ]
br i1 %34, label %679, label %675
675: ; preds = %673
%676 = ptrtoint i8* %674 to i64
%677 = sub i64 %676, %623
%678 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.55, i64 0, i64 0), i64 %677)
br label %679
679: ; preds = %675, %673
%680 = load i8*, i8** %3
%681 = load i32, i32* %10
%682 = mul i32 %624, %681
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds i8, i8* %680, i64 %683
br i1 %625, label %685, label %700
685: ; preds = %679
%686 = getelementptr inbounds i8, i8* %684, i64 %598
%687 = getelementptr inbounds i8, i8* %684, i64 %597
br label %688
688: ; preds = %685, %688
%689 = phi i8* [ %698, %688 ], [ %686, %685 ]
%690 = phi i8* [ %697, %688 ], [ %687, %685 ]
%691 = phi i8* [ %695, %688 ], [ %579, %685 ]
%692 = phi i8* [ %693, %688 ], [ %578, %685 ]
%693 = getelementptr inbounds i8, i8* %692, i64 1
%694 = load i8, i8* %692
store i8 %694, i8* %690
%695 = getelementptr inbounds i8, i8* %691, i64 1
%696 = load i8, i8* %691
store i8 %696, i8* %689
%697 = getelementptr inbounds i8, i8* %690, i64 2
%698 = getelementptr inbounds i8, i8* %689, i64 2
%699 = icmp ult i8* %693, %622
br i1 %699, label %688, label %700
700: ; preds = %688, %679
br i1 %34, label %705, label %701
701: ; preds = %700
%702 = load i32, i32* %10
%703 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.56, i64 0, i64 0), i32 %702)
%704 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.64, i64 0, i64 0))
br label %705
705: ; preds = %701, %700
%706 = load i32, i32* %20
%707 = add nsw i32 %706, -2
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %708
%710 = load i8, i8* %709
%711 = zext i8 %710 to i32
%712 = shl nuw nsw i32 %711, 8
%713 = add nsw i32 %706, -1
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %714
%716 = load i8, i8* %715
%717 = zext i8 %716 to i32
%718 = or i32 %712, %717
store i32 %718, i32* %20
%719 = load i32, i32* %10
%720 = add nsw i32 %719, 1
store i32 %720, i32* %10
%721 = icmp slt i32 %720, %617
br i1 %721, label %626, label %722
722: ; preds = %705, %603
%723 = phi i32 [ %616, %603 ], [ %718, %705 ]
%724 = add nsw i32 %723, -2
store i32 %724, i32* %20
%725 = call i32 (i32*, i8*, i32*, i32*, ...) bitcast (i32 (...)* @dskbr_ to i32 (i32*, i8*, i32*, i32*, ...)*)(i32* %16, i8* %578, i32* %20, i32* %12)
%726 = load i32, i32* %12
%727 = icmp eq i32 %726, 0
br i1 %727, label %729, label %728
728: ; preds = %722
store i32 -2, i32* %12
br label %796
729: ; preds = %722
%730 = sext i32 %581 to i64
%731 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %730
%732 = load i32, i32* %20
%733 = icmp slt i32 %581, %732
br i1 %733, label %742, label %758
734: ; preds = %752
%735 = load i32, i32* %20
br label %736
736: ; preds = %734, %742
%737 = phi i32 [ %743, %742 ], [ %735, %734 ]
%738 = phi i8* [ %744, %742 ], [ %754, %734 ]
%739 = sext i32 %737 to i64
%740 = getelementptr inbounds [10240 x i8], [10240 x i8]* %18, i64 0, i64 %739
%741 = icmp ult i8* %749, %740
br i1 %741, label %742, label %758
742: ; preds = %729, %736
%743 = phi i32 [ %737, %736 ], [ %732, %729 ]
%744 = phi i8* [ %738, %736 ], [ %579, %729 ]
%745 = phi i8* [ %749, %736 ], [ %731, %729 ]
%746 = getelementptr inbounds i8, i8* %745, i64 1
%747 = load i8, i8* %745
%748 = zext i8 %747 to i32
%749 = getelementptr inbounds i8, i8* %745, i64 2
%750 = load i8, i8* %746
store i32 0, i32* %9
%751 = icmp eq i8 %747, 0
br i1 %751, label %736, label %752
752: ; preds = %742, %752
%753 = phi i8* [ %754, %752 ], [ %744, %742 ]
%754 = getelementptr inbounds i8, i8* %753, i64 1
store i8 %750, i8* %753
%755 = load i32, i32* %9
%756 = add nsw i32 %755, 1
store i32 %756, i32* %9
%757 = icmp slt i32 %756, %748
br i1 %757, label %752, label %734
758: ; preds = %736, %729
%759 = phi i8* [ %579, %729 ], [ %738, %736 ]
br i1 %34, label %765, label %760
760: ; preds = %758
%761 = ptrtoint i8* %759 to i64
%762 = ptrtoint [10240 x i8]* %19 to i64
%763 = sub i64 %761, %762
%764 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.55, i64 0, i64 0), i64 %763)
br label %765
765: ; preds = %760, %758
%766 = load i8*, i8** %3
%767 = load i32, i32* %10
%768 = shl i32 %581, 1
%769 = mul i32 %768, %767
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds i8, i8* %766, i64 %770
%772 = icmp sgt i32 %581, 0
br i1 %772, label %773, label %788
773: ; preds = %765
%774 = getelementptr inbounds i8, i8* %771, i64 %598
%775 = getelementptr inbounds i8, i8* %771, i64 %597
br label %776
776: ; preds = %773, %776
%777 = phi i8* [ %786, %776 ], [ %774, %773 ]
%778 = phi i8* [ %785, %776 ], [ %775, %773 ]
%779 = phi i8* [ %783, %776 ], [ %579, %773 ]
%780 = phi i8* [ %781, %776 ], [ %578, %773 ]
%781 = getelementptr inbounds i8, i8* %780, i64 1
%782 = load i8, i8* %780
store i8 %782, i8* %778
%783 = getelementptr inbounds i8, i8* %779, i64 1
%784 = load i8, i8* %779
store i8 %784, i8* %777
%785 = getelementptr inbounds i8, i8* %778, i64 2
%786 = getelementptr inbounds i8, i8* %777, i64 2
%787 = icmp ult i8* %781, %731
br i1 %787, label %776, label %788
788: ; preds = %776, %765
br i1 %34, label %793, label %789
789: ; preds = %788
%790 = load i32, i32* %10
%791 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.56, i64 0, i64 0), i32 %790)
%792 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str.63, i64 0, i64 0))
br label %793
793: ; preds = %789, %788
%794 = load i8*, i8** %1
%795 = call i32 (i8*, i8*, i8*, ...) bitcast (i32 (...)* @puthd to i32 (i8*, i8*, i8*, ...)*)(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.35, i64 0, i64 0), i8* %794)
store i32 4, i32* %6
br label %796
796: ; preds = %586, %728, %637, %602, %793
br label %801
797: ; preds = %574
br i1 %34, label %800, label %798
798: ; preds = %797
%799 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.62, i64 0, i64 0))
br label %800
800: ; preds = %798, %797
store i32 -4, i32* %12
br label %801
801: ; preds = %796, %416, %312, %290, %196, %449, %442, %530, %523, %563, %570, %484, %491, %800, %562, %522, %483, %441, %140, %86, %63, %59
br i1 %34, label %804, label %802
802: ; preds = %97, %121, %801
%803 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
br label %804
804: ; preds = %96, %120, %802, %801
%805 = load i32, i32* %12
%806 = icmp eq i32 %805, 0
br i1 %806, label %816, label %807
807: ; preds = %804
%808 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbcr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %9)
%809 = load i8*, i8** %1
%810 = icmp eq i8* %809, null
br i1 %810, label %812, label %811
811: ; preds = %807
br label %812
812: ; preds = %811, %807
%813 = load i8*, i8** %3
%814 = icmp eq i8* %813, null
br i1 %814, label %818, label %815
815: ; preds = %812
br label %818
816: ; preds = %804
%817 = call i32 (i32*, i32*, ...) bitcast (i32 (...)* @dskbcr_ to i32 (i32*, i32*, ...)*)(i32* %16, i32* %12)
br label %818
818: ; preds = %812, %815, %816
br i1 %34, label %822, label %819
819: ; preds = %818
%820 = load i32, i32* %12
%821 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.61, i64 0, i64 0), i32 %820)
br label %822
822: ; preds = %819, %818
%823 = load i32, i32* %12
br label %824
824: ; preds = %35, %44, %822
%825 = phi i32 [ %823, %822 ], [ -3, %44 ], [ -3, %35 ]
ret i32 %825
}