void decode_feature(int feature, unsigned char *ucp, int len) {
  int k, num, n, profile;
  char buff[128];
  const char *cp;
  cp = "";
  switch (feature) {
  case 0:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 2), !!(ucp[2] & 1), feature);
    printf("    available profiles [more recent typically higher "
           "in list]:\n");
    for (k = 4; k < len; k += 4) {
      profile = (ucp[k] << 8) + ucp[k + 1];
      printf("      profile: %s , currentP=%d\n",
             get_profile_str(profile, buff), !!(ucp[k + 2] & 1));
    }
    break;
  case 1:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 2), !!(ucp[2] & 1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    num = (ucp[4] << 24) + (ucp[5] << 16) + (ucp[6] << 8) + ucp[7];
    switch (num) {
    case 0:
      cp = "unspecified";
      break;
    case 1:
      cp = "SCSI family";
      break;
    case 2:
      cp = "ATAPI";
      break;
    case 3:
      cp = "IEEE 1394 - 1995";
      break;
    case 4:
      cp = "IEEE 1394A";
      break;
    case 5:
      cp = "Fibre channel";
      break;
    case 6:
      cp = "IEEE 1394B";
      break;
    case 7:
      cp = "Serial ATAPI";
      break;
    case 8:
      cp = "USB (both 1 and 2)";
      break;
    case 0xffff:
      cp = "vendor unique";
      break;
    default:
      snprintf(buff, sizeof(buff), "[0x%x]", num);
      cp = buff;
      break;
    }
    printf("      Physical interface standard: %s", cp);
    if (len > 8)
      printf(", INQ2=%d, DBE=%d\n", !!(ucp[8] & 2), !!(ucp[8] & 1));
    else
      printf("\n");
    break;
  case 2:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 2), !!(ucp[2] & 1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      OCEvent=%d, ASYNC=%d\n", !!(ucp[4] & 2), !!(ucp[4] & 1));
    break;
  case 3:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 2), !!(ucp[2] & 1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    num = (ucp[4] >> 5) & 0x7;
    switch (num) {
    case 0:
      cp = "Caddy/slot type";
      break;
    case 1:
      cp = "Tray type";
      break;
    case 2:
      cp = "Pop-up type";
      break;
    case 4:
      cp = "Embedded changer with individually changeable discs";
      break;
    case 5:
      cp = "Embedded changer using a magazine";
      break;
    default:
      snprintf(buff, sizeof(buff), "[0x%x]", num);
      cp = buff;
      break;
    }
    printf("      Loading mechanism: %s\n", cp);
    printf("      Load=%d, Eject=%d, Prevent jumper=%d, Lock=%d\n",
           !!(ucp[4] & 0x10), !!(ucp[4] & 0x8), !!(ucp[4] & 0x4),
           !!(ucp[4] & 0x1));
    break;
  case 4:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      DWP=%d, WDCB=%d, SPWP=%d, SSWPP=%d\n", !!(ucp[4] & 0x8),
           !!(ucp[4] & 0x4), !!(ucp[4] & 0x2), !!(ucp[4] & 0x1));
    break;
  case 0x10:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 12) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    num = (ucp[4] << 24) + (ucp[5] << 16) + (ucp[6] << 8) + ucp[7];
    printf("      Logical block size=0x%x, blocking=0x%x, PP=%d\n", num,
           ((ucp[8] << 8) + ucp[9]), !!(ucp[10] & 0x1));
    break;
  case 0x1d:
  case 0x22:
  case 0x26:
  case 0x27:
  case 0x35:
  case 0x38:
  case 0x42:
  case 0x100:
  case 0x109:
  case 0x110:
  case 0x113:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    break;
  case 0x1e:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      DAP=%d, C2 flags=%d, CD-Text=%d\n", !!(ucp[4] & 0x80),
           !!(ucp[4] & 0x2), !!(ucp[4] & 0x1));
    break;
  case 0x1f:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len > 7)
      printf("      MULTI110=%d, Dual-RW=%d, Dual-R=%d\n", !!(ucp[4] & 0x1),
             !!(ucp[6] & 0x2), !!(ucp[6] & 0x1));
    break;
  case 0x20:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 16) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    num = (ucp[4] << 24) + (ucp[5] << 16) + (ucp[6] << 8) + ucp[7];
    n = (ucp[8] << 24) + (ucp[9] << 16) + (ucp[10] << 8) + ucp[11];
    printf("      Last lba=0x%x, Logical block size=0x%x, blocking=0x%x,"
           " PP=%d\n",
           num, n, ((ucp[12] << 8) + ucp[13]), !!(ucp[14] & 0x1));
    break;
  case 0x21:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      Data block types supported=0x%x, TRIO=%d, ARSV=%d, "
           "BUF=%d\n",
           ((ucp[4] << 8) + ucp[5]), !!(ucp[6] & 0x4), !!(ucp[6] & 0x2),
           !!(ucp[6] & 0x1));
    num = ucp[7];
    printf("      Number of link sizes=%d\n", num);
    for (k = 0; k < num; ++k)
      printf("        %d\n", ucp[8 + k]);
    break;
  case 0x23:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len > 4)
      printf("      BD-RE: RENoSA=%d, Expand=%d, QCert=%d, Cert=%d, "
             "FRF=%d\n",
             !!(ucp[4] & 0x8), !!(ucp[4] & 0x4), !!(ucp[4] & 0x2),
             !!(ucp[4] & 0x1), !!(ucp[5] & 0x80));
    if (len > 8)
      printf("      BD-R: RRM=%d\n", !!(ucp[8] & 0x1));
    break;
  case 0x24:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len > 4)
      printf("      SSA=%d\n", !!(ucp[4] & 0x80));
    break;
  case 0x25:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 12) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    num = (ucp[4] << 24) + (ucp[5] << 16) + (ucp[6] << 8) + ucp[7];
    printf("      Logical block size=0x%x, blocking=0x%x, PP=%d\n", num,
           ((ucp[8] << 8) + ucp[9]), !!(ucp[10] & 0x1));
    break;
  case 0x28:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len > 4)
      printf("      DVD+Write=%d, DVD+Read=%d, Write=%d\n", !!(ucp[4] & 0x4),
             !!(ucp[4] & 0x2), !!(ucp[4] & 0x1));
    break;
  case 0x29:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      DRT-DM=%d, number of DBI cache zones=0x%x, number of "
           "entries=0x%x\n",
           !!(ucp[4] & 0x1), ucp[5], ((ucp[6] << 8) + ucp[7]));
    break;
  case 0x2a:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      Write=%d, Quick start=%d, Close only=%d\n", !!(ucp[4] & 0x1),
           !!(ucp[5] & 0x2), !!(ucp[5] & 0x1));
    break;
  case 0x2b:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      Write=%d\n", !!(ucp[4] & 0x1));
    break;
  case 0x2c:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      DSDG=%d, DSDR=%d, Intermediate=%d, Blank=%d\n",
           !!(ucp[4] & 0x8), !!(ucp[4] & 0x4), !!(ucp[4] & 0x2),
           !!(ucp[4] & 0x1));
    break;
  case 0x2d:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      BUF=%d, R-W raw=%d, R-W pack=%d, Test write=%d\n",
           !!(ucp[4] & 0x40), !!(ucp[4] & 0x10), !!(ucp[4] & 0x8),
           !!(ucp[4] & 0x4));
    printf("      CD-RW=%d, R-W sub-code=%d, Data type supported=%d\n",
           !!(ucp[4] & 0x2), !!(ucp[4] & 0x1), (ucp[6] << 8) + ucp[7]);
    break;
  case 0x2e:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      BUF=%d, SAO=%d, Raw MS=%d, Raw=%d\n", !!(ucp[4] & 0x40),
           !!(ucp[4] & 0x20), !!(ucp[4] & 0x10), !!(ucp[4] & 0x8));
    printf("      Test write=%d, CD-RW=%d, R-W=%d\n", !!(ucp[4] & 0x4),
           !!(ucp[4] & 0x2), !!(ucp[4] & 0x1));
    printf("      Maximum cue sheet length=0x%x\n",
           (ucp[5] << 16) + (ucp[6] << 8) + ucp[7]);
    break;
  case 0x2f:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      BUF=%d, RDL=%d, Test write=%d, DVD-RW SL=%d\n",
           !!(ucp[4] & 0x40), !!(ucp[4] & 0x8), !!(ucp[4] & 0x4),
           !!(ucp[4] & 0x2));
    break;
  case 0x33:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    num = ucp[7];
    printf("      Number of link sizes=%d\n", num);
    for (k = 0; k < num; ++k)
      printf("        %d\n", ucp[8 + k]);
    break;
  case 0x34:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      CLJB=%d\n", !!(ucp[4] & 0x1));
    printf("      Buffer block size=%d\n", ucp[7]);
    break;
  case 0x37:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      CD-RW media sub-type support (bitmask)=0x%x\n", ucp[5]);
    break;
  case 0x3a:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      write=%d, quick_start=%d, close_only=%d\n", !!(ucp[4] & 0x1),
           !!(ucp[5] & 0x2), !!(ucp[5] & 0x1));
    break;
  case 0x3b:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      write=%d\n", !!(ucp[4] & 0x1));
    break;
  case 0x40:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 32) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      Bitmaps for BD-RE read support:\n");
    printf("        Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, "
           "Class 3=0x%x\n",
           (ucp[8] << 8) + ucp[9], (ucp[10] << 8) + ucp[11],
           (ucp[12] << 8) + ucp[13], (ucp[14] << 8) + ucp[15]);
    printf("      Bitmaps for BD-R read support:\n");
    printf("        Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, "
           "Class 3=0x%x\n",
           (ucp[16] << 8) + ucp[17], (ucp[18] << 8) + ucp[19],
           (ucp[20] << 8) + ucp[21], (ucp[22] << 8) + ucp[23]);
    printf("      Bitmaps for BD-ROM read support:\n");
    printf("        Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, "
           "Class 3=0x%x\n",
           (ucp[24] << 8) + ucp[25], (ucp[26] << 8) + ucp[27],
           (ucp[28] << 8) + ucp[29], (ucp[30] << 8) + ucp[31]);
    break;
  case 0x41:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 32) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      SVNR=%d\n", !!(ucp[4] & 0x1));
    printf("      Bitmaps for BD-RE write support:\n");
    printf("        Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, "
           "Class 3=0x%x\n",
           (ucp[8] << 8) + ucp[9], (ucp[10] << 8) + ucp[11],
           (ucp[12] << 8) + ucp[13], (ucp[14] << 8) + ucp[15]);
    printf("      Bitmaps for BD-R write support:\n");
    printf("        Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, "
           "Class 3=0x%x\n",
           (ucp[16] << 8) + ucp[17], (ucp[18] << 8) + ucp[19],
           (ucp[20] << 8) + ucp[21], (ucp[22] << 8) + ucp[23]);
    printf("      Bitmaps for BD-ROM write support:\n");
    printf("        Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, "
           "Class 3=0x%x\n",
           (ucp[24] << 8) + ucp[25], (ucp[26] << 8) + ucp[27],
           (ucp[28] << 8) + ucp[29], (ucp[30] << 8) + ucp[31]);
    break;
  case 0x50:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      HD DVD-R=%d, HD DVD-RAM=%d\n", !!(ucp[4] & 0x1),
           !!(ucp[6] & 0x1));
    break;
  case 0x51:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      HD DVD-R=%d, HD DVD-RAM=%d\n", !!(ucp[4] & 0x1),
           !!(ucp[6] & 0x1));
    break;
  case 0x52:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      BGP=%d\n", !!(ucp[4] & 0x1));
    break;
  case 0x80:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      RI=%d\n", !!(ucp[4] & 0x1));
    break;
  case 0x101:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      PP=%d\n", !!(ucp[4] & 0x1));
    break;
  case 0x102:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      SCC=%d, SDP=%d, highest slot number=%d\n", !!(ucp[4] & 0x10),
           !!(ucp[4] & 0x4), (ucp[7] & 0x1f));
    break;
  case 0x103:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      Scan=%d, SCM=%d, SV=%d, number of volume levels=%d\n",
           !!(ucp[4] & 0x4), !!(ucp[4] & 0x2), !!(ucp[4] & 0x1),
           (ucp[6] << 8) + ucp[7]);
    break;
  case 0x104:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 4) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    if (len > 4)
      printf("      M5=%d\n", !!(ucp[4] & 0x1));
    break;
  case 0x105:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len > 7) {
      printf("      Group 3=%d, unit length=%d\n", !!(ucp[4] & 0x1),
             (ucp[6] << 8) + ucp[7]);
    }
    break;
  case 0x106:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      CSS version=%d\n", ucp[7]);
    break;
  case 0x107:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      RBCB=%d, SCS=%d, MP2A=%d, WSPD=%d, SW=%d\n",
           !!(ucp[4] & 0x10), !!(ucp[4] & 0x8), !!(ucp[4] & 0x4),
           !!(ucp[4] & 0x2), !!(ucp[4] & 0x1));
    break;
  case 0x108:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    num = len - 4;
    n = sizeof(buff) - 1;
    n = ((num < n) ? num : n);
    strncpy(buff, (const char *)(ucp + 4), n);
    buff[n] = '\0';
    printf("      Drive serial number: %s\n", buff);
    break;
  case 0x10a:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    printf("      Disc control blocks:\n");
    for (k = 4; k < len; k += 4) {
      printf("        0x%x\n", ((unsigned int)ucp[k] << 24) +
                                   (ucp[k + 1] << 16) + (ucp[k + 2] << 8) +
                                   ucp[k + 3]);
    }
    break;
  case 0x10b:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      CPRM version=%d\n", ucp[7]);
    break;
  case 0x10c:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 20) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      %.2s%.2s/%.2s/%.2s %.2s:%.2s:%.2s\n", ucp + 4, ucp + 6,
           ucp + 8, ucp + 10, ucp + 12, ucp + 14, ucp + 16);
    break;
  case 0x10d:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      BNG=%d, Block count for binding nonce=%d\n", !!(ucp[4] & 0x1),
           ucp[5]);
    printf("      Number of AGIDs=%d, AACS version=%d\n", (ucp[6] & 0xf),
           ucp[7]);
    break;
  case 0x10e:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      Maximum number of scrambled extent information "
           "entries=%d\n",
           ucp[4]);
    break;
  case 0x120:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("      BD CPS major:minor version number=%d:%d, max open "
           "SACs=%d\n",
           ((ucp[5] >> 4) & 0xf), (ucp[5] & 0xf), ucp[6] & 0x3);
    break;
  case 0x142:
    printf("    version=%d, persist=%d, current=%d [0x%x]\n",
           ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1), feature);
    if (len < 8) {
      printf("      additional length [%d] too short\n", len - 4);
      break;
    }
    printf("    PSAU=%d, LOSPB=%d, ME=%d\n", !!(ucp[4] & 0x80),
           !!(ucp[4] & 0x40), !!(ucp[4] & 0x1));
    num = ucp[5];
    printf("      Profile numbers:\n");
    for (k = 6; (num > 0) && (k < len); --num, k += 2) {
      printf("        %d\n", ((unsigned int)ucp[k] << 8) + ucp[k + 1]);
    }
    break;
  default:
    printf("    Unknown feature [0x%x], version=%d persist=%d, "
           "current=%d\n",
           feature, ((ucp[2] >> 2) & 0xf), !!(ucp[2] & 0x2), !!(ucp[2] & 0x1));
    dStrHex((const char *)ucp, len, 1);
    break;
  }
}


x86 assembly (clang, -O0):
<decode_feature>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
lea    0x3426(%rip),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0xc0(%rbp)
sub    $0x142,%rax
ja     3e6d <decode_feature+0x2d1d>
mov    -0xc0(%rbp),%rax
lea    0x2e69(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x3337(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x3358(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x4,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128c <decode_feature+0x13c>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%edi
lea    -0xb0(%rbp),%rsi
mov    $0x0,%al
call   1070 <get_profile_str@plt>
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
lea    0x331c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
jmp    1209 <decode_feature+0xb9>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x3246(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    1308 <decode_feature+0x1b8>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x32b8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
bswap  %eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xc4(%rbp)
test   %eax,%eax
je     13e0 <decode_feature+0x290>
jmp    132a <decode_feature+0x1da>
mov    -0xc4(%rbp),%eax
sub    $0x1,%eax
je     13f3 <decode_feature+0x2a3>
jmp    133e <decode_feature+0x1ee>
mov    -0xc4(%rbp),%eax
sub    $0x2,%eax
je     1406 <decode_feature+0x2b6>
jmp    1352 <decode_feature+0x202>
mov    -0xc4(%rbp),%eax
sub    $0x3,%eax
je     1419 <decode_feature+0x2c9>
jmp    1366 <decode_feature+0x216>
mov    -0xc4(%rbp),%eax
sub    $0x4,%eax
je     142c <decode_feature+0x2dc>
jmp    137a <decode_feature+0x22a>
mov    -0xc4(%rbp),%eax
sub    $0x5,%eax
je     143f <decode_feature+0x2ef>
jmp    138e <decode_feature+0x23e>
mov    -0xc4(%rbp),%eax
sub    $0x6,%eax
je     1452 <decode_feature+0x302>
jmp    13a2 <decode_feature+0x252>
mov    -0xc4(%rbp),%eax
sub    $0x7,%eax
je     1465 <decode_feature+0x315>
jmp    13b6 <decode_feature+0x266>
mov    -0xc4(%rbp),%eax
sub    $0x8,%eax
je     1478 <decode_feature+0x328>
jmp    13ca <decode_feature+0x27a>
mov    -0xc4(%rbp),%eax
sub    $0xffff,%eax
je     148b <decode_feature+0x33b>
jmp    149e <decode_feature+0x34e>
lea    0x31f5(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31ee(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x3223(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31d4(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31d2(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31ca(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31c5(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31bd(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31b7(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    0x31b7(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    14c9 <decode_feature+0x379>
lea    -0xb0(%rbp),%rdi
mov    -0x1c(%rbp),%ecx
mov    $0x80,%esi
lea    0x31a3(%rip),%rdx
mov    $0x0,%al
call   1060 <snprintf@plt>
lea    -0xb0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rsi
lea    0x3187(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jle    152f <decode_feature+0x3df>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
lea    0x3161(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    153d <decode_feature+0x3ed>
lea    0x305b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2f95(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    15b9 <decode_feature+0x469>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x3007(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
lea    0x30a3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2ed7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    1677 <decode_feature+0x527>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2f49(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shr    $0x5,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %rax,-0xd0(%rbp)
sub    $0x5,%rax
ja     170f <decode_feature+0x5bf>
mov    -0xd0(%rbp),%rax
lea    0x2e65(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x2ffc(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    173a <decode_feature+0x5ea>
lea    0x2ff9(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    173a <decode_feature+0x5ea>
lea    0x2ff0(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    173a <decode_feature+0x5ea>
lea    0x2fe9(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    173a <decode_feature+0x5ea>
lea    0x300a(%rip),%rax
mov    %rax,-0xb8(%rbp)
jmp    173a <decode_feature+0x5ea>
lea    -0xb0(%rbp),%rdi
mov    -0x1c(%rbp),%ecx
mov    $0x80,%esi
lea    0x2f32(%rip),%rdx
mov    $0x0,%al
call   1060 <snprintf@plt>
lea    -0xb0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rsi
lea    0x2fe7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x2f8d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2d0c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    1842 <decode_feature+0x6f2>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2d7e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x2ecf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2c19(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0xc,-0x14(%rbp)
jge    1935 <decode_feature+0x7e5>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2c8b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x2e0b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2b2b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2ad2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    1a7c <decode_feature+0x92c>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2b44(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x2d0d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x29f8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x7,-0x14(%rbp)
jle    1b99 <decode_feature+0xa49>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x2c75(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2939(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x10,-0x14(%rbp)
jge    1c15 <decode_feature+0xac5>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x29ab(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x2b7b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2815(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    1d39 <decode_feature+0xbe9>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2887(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x2ad1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0x2af6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e07 <decode_feature+0xcb7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
lea    0x2ae3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1dce <decode_feature+0xc7e>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x26cb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x4,-0x14(%rbp)
jle    1efe <decode_feature+0xdae>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
lea    0x29ea(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jle    1f30 <decode_feature+0xde0>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x29f6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x25a2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x4,-0x14(%rbp)
jle    1fbd <decode_feature+0xe6d>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x297d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2515(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0xc,-0x14(%rbp)
jge    2039 <decode_feature+0xee9>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2587(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x2707(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2427(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x4,-0x14(%rbp)
jle    216a <decode_feature+0x101a>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x27de(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2368(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    21e6 <decode_feature+0x1096>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x23da(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%edx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    %eax,%ecx
lea    0x2748(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x22a7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    22a7 <decode_feature+0x1157>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2319(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x26b9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x21cf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    237f <decode_feature+0x122f>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x2241(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x2644(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x212b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    2423 <decode_feature+0x12d3>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x219d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x2561(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x2038(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    2516 <decode_feature+0x13c6>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x20aa(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x24a1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    %eax,%ecx
lea    0x2480(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1eee(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    2660 <decode_feature+0x1510>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1f60(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x23c6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x2393(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%esi
shl    $0x10,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
shl    $0x8,%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    %eax,%esi
lea    0x238a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1d6f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    27df <decode_feature+0x168f>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1de1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x22bc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1c7c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    28d2 <decode_feature+0x1782>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1cee(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0x1fcf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    292e <decode_feature+0x17de>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
lea    0x1fbc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    28f5 <decode_feature+0x17a5>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1ba4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    29aa <decode_feature+0x185a>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1c16(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x2173(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%esi
lea    0x216c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1aea(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    2a64 <decode_feature+0x1914>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1b5c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%esi
lea    0x20f6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1a58(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    2af6 <decode_feature+0x19a6>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1aca(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x2051(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1980(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    2bce <decode_feature+0x1a7e>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x19f2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x1fdc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x18dc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x20,-0x14(%rbp)
jge    2c72 <decode_feature+0x1b22>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x194e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
lea    0x1f62(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
add    %eax,%r8d
lea    0x1f24(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1f56(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x10(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0x12(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x13(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x14(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x15(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x16(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x17(%rax),%eax
add    %eax,%r8d
lea    0x1eb1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1f09(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x18(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x19(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0x1a(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x1b(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x1c(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x1d(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x1e(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x1f(%rax),%eax
add    %eax,%r8d
lea    0x1e3e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1707(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x20,-0x14(%rbp)
jge    2e47 <decode_feature+0x1cf7>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1779(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x1e28(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1e29(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
add    %eax,%r8d
lea    0x1d27(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1dde(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x10(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0x12(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x13(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x14(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x15(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x16(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x17(%rax),%eax
add    %eax,%r8d
lea    0x1cb4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1d92(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x18(%rax),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
movzbl 0x19(%rax),%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
movzbl 0x1a(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x1b(%rax),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x1c(%rax),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x1d(%rax),%eax
add    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x1e(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x1f(%rax),%eax
add    %eax,%r8d
lea    0x1c41(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x150a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3044 <decode_feature+0x1ef4>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x157c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
lea    0x1c98(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x144c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3102 <decode_feature+0x1fb2>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x14be(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
lea    0x1bda(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x138e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    31c0 <decode_feature+0x2070>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1400(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x1b58(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x12ea(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3264 <decode_feature+0x2114>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x135c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x1ac2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x1246(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3308 <decode_feature+0x21b8>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x12b8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x1a2b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x11a2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    33ac <decode_feature+0x225c>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x1214(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%ecx
and    $0x1f,%ecx
lea    0x196f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x10d9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3475 <decode_feature+0x2325>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x114b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%r8d
shl    $0x8,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    %eax,%r8d
lea    0x18ad(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xfe9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x4,-0x14(%rbp)
jge    3565 <decode_feature+0x2415>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x105b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
cmpl   $0x4,-0x14(%rbp)
jle    3597 <decode_feature+0x2447>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
lea    0x1839(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xf3b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x7,-0x14(%rbp)
jle    3637 <decode_feature+0x24e7>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%edx
shl    $0x8,%edx
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    %eax,%edx
lea    0x17a6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xe9b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    36b3 <decode_feature+0x2563>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0xf0d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%esi
lea    0x1736(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xe09(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3745 <decode_feature+0x25f5>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0xe7b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
lea    0x163e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xcfb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x7f,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    385a <decode_feature+0x270a>
mov    -0x1c(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    3863 <decode_feature+0x2713>
mov    -0x20(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x20(%rbp)
lea    -0xb0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x4,%rsi
movslq -0x20(%rbp),%rdx
call   1030 <strncpy@plt>
movslq -0x20(%rbp),%rax
movb   $0x0,-0xb0(%rbp,%rax,1)
lea    -0xb0(%rbp),%rsi
lea    0x15a0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xc2d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1558(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x4,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    3989 <decode_feature+0x2839>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
shl    $0x18,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
add    %eax,%esi
lea    0x1505(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
jmp    3913 <decode_feature+0x27c3>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xb49(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3a05 <decode_feature+0x28b5>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0xbbb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%esi
lea    0x1473(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0xab7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x14,-0x14(%rbp)
jge    3a97 <decode_feature+0x2947>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0xb29(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rsi
add    $0x4,%rsi
mov    -0x10(%rbp),%rdx
add    $0x6,%rdx
mov    -0x10(%rbp),%rcx
add    $0x8,%rcx
mov    -0x10(%rbp),%r8
add    $0xa,%r8
mov    -0x10(%rbp),%r9
add    $0xc,%r9
mov    -0x10(%rbp),%r10
add    $0xe,%r10
mov    -0x10(%rbp),%rax
add    $0x10,%rax
lea    0x13c8(%rip),%rdi
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x9ec(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3b62 <decode_feature+0x2a12>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0xa5e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%edx
lea    0x133c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%edx
lea    0x134b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x91f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3c2f <decode_feature+0x2adf>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x991(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%esi
lea    0x12e4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x88d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3cc1 <decode_feature+0x2b71>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x8ff(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%esi
sar    $0x4,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%edx
and    $0xf,%edx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%ecx
and    $0x3,%ecx
lea    0x1277(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%esi
sar    $0x2,%esi
and    $0xf,%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x4(%rbp),%r8d
lea    0x7df(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x8,-0x14(%rbp)
jge    3d6f <decode_feature+0x2c1f>
mov    -0x14(%rbp),%esi
sub    $0x4,%esi
lea    0x851(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
lea    0x11de(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    %eax,-0x1c(%rbp)
lea    0x11e3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x6,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0xd5(%rbp)
jle    3e0e <decode_feature+0x2cbe>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xd5(%rbp)
mov    -0xd5(%rbp),%al
test   $0x1,%al
jne    3e21 <decode_feature+0x2cd1>
jmp    3e68 <decode_feature+0x2d18>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
shl    $0x8,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
add    %eax,%esi
lea    0xa8b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
jmp    3ded <decode_feature+0x2c9d>
jmp    3ed4 <decode_feature+0x2d84>
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%edx
sar    $0x2,%edx
and    $0xf,%edx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
lea    0x1120(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x1,%edx
mov    $0x0,%al
call   1040 <dStrHex@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decode_feature>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x80,%rsp
mov    %edx,%r15d
mov    %rsi,%r12
mov    %edi,%eax
cmp    $0x142,%edi
ja     202e <decode_feature+0xebe>
mov    %eax,%ecx
lea    0x1e64(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2384(%rip),%rdi
mov    %eax,%r8d
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <printf@plt>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x234c(%rip),%rdi
xor    %r8d,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x2de8(%rip),%rdi
call   1050 <puts@plt>
cmp    $0x5,%r15d
jl     26dd <decode_feature+0x156d>
mov    $0x4,%ebp
mov    %rsp,%r14
lea    0x234c(%rip),%rbx
nopl   0x0(%rax,%rax,1)
movzwl (%r12,%rbp,1),%edi
shl    $0x10,%edi
bswap  %edi
mov    %r14,%rsi
xor    %eax,%eax
call   1090 <get_profile_str@plt>
movzbl 0x2(%r12,%rbp,1),%edx
and    $0x1,%edx
mov    %rbx,%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x4,%rbp
cmp    %r15d,%ebp
jl     1230 <decode_feature+0xc0>
jmp    26dd <decode_feature+0x156d>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x22c2(%rip),%rdi
mov    $0x1,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
mov    0x4(%r12),%ecx
bswap  %ecx
cmp    $0x8,%ecx
ja     2633 <decode_feature+0x14c3>
lea    0x230c(%rip),%r14
lea    0x2251(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
lea    0x2301(%rip),%r14
jmp    269c <decode_feature+0x152c>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2259(%rip),%rdi
mov    $0x2,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%edx
mov    %edx,%esi
shr    %esi
and    $0x1,%esi
and    $0x1,%edx
lea    0x235e(%rip),%rdi
jmp    23f8 <decode_feature+0x1288>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2207(%rip),%rdi
mov    $0x3,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%eax
mov    %rax,%rcx
shr    $0x5,%rcx
cmp    $0xc0,%rax
jae    137e <decode_feature+0x20e>
movzbl %cl,%eax
mov    $0x37,%edx
bt     %eax,%edx
jb     25dc <decode_feature+0x146c>
mov    %rsp,%rbx
lea    0x22b3(%rip),%rdx
mov    $0x80,%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <snprintf@plt>
jmp    25ea <decode_feature+0x147a>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x218d(%rip),%rdi
mov    $0x4,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x3,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x2,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    %ecx
and    $0x1,%ecx
and    $0x1,%r8d
lea    0x2368(%rip),%rdi
jmp    11c7 <decode_feature+0x57>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2127(%rip),%rdi
mov    $0x10,%r8d
jmp    15e9 <decode_feature+0x479>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x20fd(%rip),%rdi
mov    $0x1e,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%ecx
mov    %ecx,%esi
shr    $0x7,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2346(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x20a6(%rip),%rdi
mov    $0x20,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0xf,%r15d
jle    2539 <decode_feature+0x13c9>
mov    0x4(%r12),%esi
mov    0x8(%r12),%edx
bswap  %esi
bswap  %edx
movzwl 0xc(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
movzbl 0xe(%r12),%r8d
and    $0x1,%r8d
lea    0x2332(%rip),%rdi
jmp    11c7 <decode_feature+0x57>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2041(%rip),%rdi
mov    $0x23,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x5,%r15d
jl     26dd <decode_feature+0x156d>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x3,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x2,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    %ecx
and    $0x1,%ecx
and    $0x1,%r8d
movzbl 0x5(%r12),%r9d
shr    $0x7,%r9d
lea    0x2372(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x9,%r15d
jb     26dd <decode_feature+0x156d>
movzbl 0x8(%r12),%esi
and    $0x1,%esi
lea    0x238f(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1fb0(%rip),%rdi
mov    $0x24,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x5,%r15d
jl     26dd <decode_feature+0x156d>
movzbl 0x4(%r12),%esi
shr    $0x7,%esi
lea    0x2358(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1f65(%rip),%rdi
mov    $0x25,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0xb,%r15d
jle    2539 <decode_feature+0x13c9>
mov    0x4(%r12),%esi
bswap  %esi
movzwl 0x8(%r12),%edx
shl    $0x10,%edx
bswap  %edx
movzbl 0xa(%r12),%ecx
and    $0x1,%ecx
lea    0x2173(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1f08(%rip),%rdi
mov    $0x28,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x5,%r15d
jl     26dd <decode_feature+0x156d>
movzbl 0x4(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0x1,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x22af(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1eae(%rip),%rdi
mov    $0x29,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzbl 0x5(%r12),%edx
movzwl 0x6(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
lea    0x227e(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1e52(%rip),%rdi
mov    $0x2c,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x3,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x2,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    %ecx
and    $0x1,%ecx
and    $0x1,%r8d
lea    0x22a0(%rip),%rdi
jmp    11c7 <decode_feature+0x57>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1dec(%rip),%rdi
mov    $0x2d,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x6,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x4,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    $0x3,%ecx
and    $0x1,%ecx
shr    $0x2,%r8d
and    $0x1,%r8d
lea    0x2268(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4(%r12),%edx
mov    %edx,%esi
shr    %esi
and    $0x1,%esi
and    $0x1,%edx
movzwl 0x6(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
lea    0x2275(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1d58(%rip),%rdi
mov    $0x2e,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x6,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x5,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    $0x4,%ecx
and    $0x1,%ecx
shr    $0x3,%r8d
and    $0x1,%r8d
lea    0x2243(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0x1,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x2246(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x5(%r12),%eax
shl    $0x10,%eax
movzbl 0x6(%r12),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movzbl 0x7(%r12),%esi
or     %ecx,%esi
lea    0x2243(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1c9d(%rip),%rdi
mov    $0x2f,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x6,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x3,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    $0x2,%ecx
and    $0x1,%ecx
shr    %r8d
and    $0x1,%r8d
lea    0x21fe(%rip),%rdi
jmp    11c7 <decode_feature+0x57>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1c33(%rip),%rdi
mov    $0x34,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x21e6(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x7(%r12),%esi
lea    0x21e1(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1bd4(%rip),%rdi
mov    $0x37,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x5(%r12),%esi
lea    0x21b5(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1b8c(%rip),%rdi
mov    $0x3b,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x21cc(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1b41(%rip),%rdi
mov    $0x40,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x1f,%r15d
jle    2539 <decode_feature+0x13c9>
lea    0x255e(%rip),%rdi
call   1050 <puts@plt>
movzwl 0x8(%r12),%esi
shl    $0x10,%esi
bswap  %esi
movzwl 0xa(%r12),%edx
shl    $0x10,%edx
bswap  %edx
movzwl 0xc(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
movzwl 0xe(%r12),%r8d
shl    $0x10,%r8d
bswap  %r8d
lea    0x2160(%rip),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x2539(%rip),%rdi
call   1050 <puts@plt>
movzwl 0x10(%r12),%esi
shl    $0x10,%esi
bswap  %esi
movzwl 0x12(%r12),%edx
shl    $0x10,%edx
bswap  %edx
movzwl 0x14(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
movzwl 0x16(%r12),%r8d
shl    $0x10,%r8d
bswap  %r8d
mov    %rbp,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x251a(%rip),%rdi
jmp    1b9c <decode_feature+0xa2c>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1a70(%rip),%rdi
mov    $0x41,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x1f,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x2100(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x2401(%rip),%rdi
call   1050 <puts@plt>
movzwl 0x8(%r12),%esi
shl    $0x10,%esi
bswap  %esi
movzwl 0xa(%r12),%edx
shl    $0x10,%edx
bswap  %edx
movzwl 0xc(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
movzwl 0xe(%r12),%r8d
shl    $0x10,%r8d
bswap  %r8d
lea    0x2078(%rip),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x23dd(%rip),%rdi
call   1050 <puts@plt>
movzwl 0x10(%r12),%esi
shl    $0x10,%esi
bswap  %esi
movzwl 0x12(%r12),%edx
shl    $0x10,%edx
bswap  %edx
movzwl 0x14(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
movzwl 0x16(%r12),%r8d
shl    $0x10,%r8d
bswap  %r8d
mov    %rbp,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x23bf(%rip),%rdi
call   1050 <puts@plt>
movzwl 0x18(%r12),%esi
shl    $0x10,%esi
bswap  %esi
movzwl 0x1a(%r12),%edx
shl    $0x10,%edx
bswap  %edx
movzwl 0x1c(%r12),%ecx
shl    $0x10,%ecx
bswap  %ecx
movzwl 0x1e(%r12),%r8d
shl    $0x10,%r8d
bswap  %r8d
mov    %rbp,%rdi
jmp    11c7 <decode_feature+0x57>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1952(%rip),%rdi
mov    $0x50,%r8d
jmp    1c23 <decode_feature+0xab3>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x192b(%rip),%rdi
mov    $0x51,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzbl 0x6(%r12),%edx
and    $0x1,%edx
lea    0x1fc1(%rip),%rdi
jmp    23f8 <decode_feature+0x1288>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x18d7(%rip),%rdi
mov    $0x52,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x1f98(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x188c(%rip),%rdi
mov    $0x102,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%edx
mov    %edx,%esi
shr    $0x4,%esi
and    $0x1,%esi
shr    $0x2,%edx
and    $0x1,%edx
movzbl 0x7(%r12),%ecx
and    $0x1f,%ecx
lea    0x1f61(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x182d(%rip),%rdi
mov    $0x103,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0x1,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
movzwl 0x6(%r12),%r8d
shl    $0x10,%r8d
bswap  %r8d
lea    0x1f28(%rip),%rdi
jmp    11c7 <decode_feature+0x57>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x17c6(%rip),%rdi
mov    $0x104,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x3,%r15d
jle    2539 <decode_feature+0x13c9>
cmp    $0x4,%r15d
je     26dd <decode_feature+0x156d>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x1f0d(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1771(%rip),%rdi
mov    $0x106,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x7(%r12),%esi
lea    0x1ef4(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1729(%rip),%rdi
mov    $0x107,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%r9d
mov    %r9d,%esi
shr    $0x4,%esi
and    $0x1,%esi
mov    %r9d,%edx
shr    $0x3,%edx
and    $0x1,%edx
mov    %r9d,%ecx
shr    $0x2,%ecx
and    $0x1,%ecx
mov    %r9d,%r8d
shr    %r8d
and    $0x1,%r8d
and    $0x1,%r9d
lea    0x1e99(%rip),%rdi
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <printf@plt>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x16a7(%rip),%rdi
mov    $0x108,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x83,%r15d
mov    $0x83,%eax
cmovl  %r15d,%eax
movslq %eax,%rbp
lea    -0x4(%rbp),%rdx
add    $0x4,%r12
mov    %rsp,%rbx
mov    %rbx,%rdi
mov    %r12,%rsi
call   1040 <strncpy@plt>
movb   $0x0,-0x4(%rsp,%rbp,1)
lea    0x1e52(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
jmp    26dd <decode_feature+0x156d>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1637(%rip),%rdi
mov    $0x10c,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x13,%r15d
jle    2539 <decode_feature+0x13c9>
lea    0x4(%r12),%rsi
lea    0x6(%r12),%rdx
lea    0x8(%r12),%rcx
lea    0xa(%r12),%r8
lea    0xc(%r12),%r9
lea    0xe(%r12),%rbp
add    $0x10,%r12
lea    0x1e28(%rip),%rdi
xor    %eax,%eax
push   %r12
push   %rbp
call   1070 <printf@plt>
add    $0x90,%rsp
jmp    26e4 <decode_feature+0x1574>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x15c2(%rip),%rdi
mov    $0x10d,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzbl 0x5(%r12),%edx
lea    0x1def(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x6(%r12),%esi
and    $0xf,%esi
movzbl 0x7(%r12),%edx
lea    0x1e02(%rip),%rdi
jmp    23f8 <decode_feature+0x1288>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1554(%rip),%rdi
mov    $0x120,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x5(%r12),%edx
mov    %edx,%esi
shr    $0x4,%esi
and    $0xf,%edx
movzbl 0x6(%r12),%ecx
and    $0x3,%ecx
lea    0x1e15(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%r8d
mov    %r8d,%edx
shr    $0x2,%edx
and    $0xf,%edx
mov    %r8d,%ecx
shr    %ecx
and    $0x1,%ecx
and    $0x1,%r8d
lea    0x1e4d(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r12,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <dStrHex@plt>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x14af(%rip),%rdi
mov    $0x1f,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x8,%r15d
jl     26dd <decode_feature+0x156d>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzbl 0x6(%r12),%ecx
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x171b(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1454(%rip),%rdi
mov    $0x21,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzwl 0x4(%r12),%esi
shl    $0x10,%esi
bswap  %esi
movzbl 0x6(%r12),%r8d
mov    %r8d,%edx
shr    $0x2,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    %ecx
and    $0x1,%ecx
and    $0x1,%r8d
lea    0x1721(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x7(%r12),%ebx
lea    0x174e(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <printf@plt>
test   %ebx,%ebx
je     26dd <decode_feature+0x156d>
lea    0x1755(%rip),%r14
xor    %ebp,%ebp
movzbl 0x8(%r12,%rbp,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2166 <decode_feature+0xff6>
jmp    26dd <decode_feature+0x156d>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x13a5(%rip),%rdi
mov    $0x2a,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzbl 0x5(%r12),%ecx
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x17bf(%rip),%rdi
jmp    22fb <decode_feature+0x118b>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x134a(%rip),%rdi
mov    $0x2b,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x17a3(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x12ff(%rip),%rdi
mov    $0x33,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x7(%r12),%ebp
lea    0x162d(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1070 <printf@plt>
test   %ebp,%ebp
je     26dd <decode_feature+0x156d>
lea    0x1634(%rip),%r14
xor    %ebx,%ebx
movzbl 0x8(%r12,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    2287 <decode_feature+0x1117>
jmp    26dd <decode_feature+0x156d>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1284(%rip),%rdi
mov    $0x3a,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzbl 0x5(%r12),%ecx
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1885(%rip),%rdi
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <printf@plt>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1218(%rip),%rdi
mov    $0x80,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x18e7(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x11cd(%rip),%rdi
mov    $0x101,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
lea    0x18a9(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1182(%rip),%rdi
mov    $0x105,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x8,%r15d
jl     26dd <decode_feature+0x156d>
movzbl 0x4(%r12),%esi
and    $0x1,%esi
movzwl 0x6(%r12),%edx
shl    $0x10,%edx
bswap  %edx
lea    0x18d5(%rip),%rdi
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <printf@plt>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x111b(%rip),%rdi
mov    $0x10a,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x1ab2(%rip),%rdi
call   1050 <puts@plt>
cmp    $0x5,%r15d
jl     26dd <decode_feature+0x156d>
mov    $0x4,%ebp
lea    0x18f8(%rip),%rbx
nopl   0x0(%rax)
mov    (%r12,%rbp,1),%esi
bswap  %esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x4,%rbp
cmp    %r15d,%ebp
jl     2460 <decode_feature+0x12f0>
jmp    26dd <decode_feature+0x156d>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x10ab(%rip),%rdi
mov    $0x10b,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x7(%r12),%esi
lea    0x18a1(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1063(%rip),%rdi
mov    $0x10e,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jle    2539 <decode_feature+0x13c9>
movzbl 0x4(%r12),%esi
lea    0x18f8(%rip),%rdi
jmp    2547 <decode_feature+0x13d7>
movzbl 0x2(%r12),%ecx
mov    %ecx,%esi
shr    $0x2,%esi
and    $0xf,%esi
mov    %ecx,%edx
shr    %edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1022(%rip),%rdi
mov    $0x142,%r8d
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x7,%r15d
jg     255d <decode_feature+0x13ed>
add    $0xfffffffc,%r15d
lea    0x1054(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <printf@plt>
movzbl 0x4(%r12),%ecx
mov    %ecx,%esi
shr    $0x7,%esi
mov    %ecx,%edx
shr    $0x6,%edx
and    $0x1,%edx
and    $0x1,%ecx
lea    0x1905(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x5(%r12),%ebp
lea    0x194e(%rip),%rdi
call   1050 <puts@plt>
test   %ebp,%ebp
je     26dd <decode_feature+0x156d>
mov    %r15d,%r15d
mov    $0x8,%ebx
lea    0x130f(%rip),%r14
movzwl -0x2(%r12,%rbx,1),%esi
shl    $0x10,%esi
bswap  %esi
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x2,%ebp
jb     26dd <decode_feature+0x156d>
add    $0xffffffff,%ebp
lea    0x2(%rbx),%rax
cmp    %r15,%rbx
mov    %rax,%rbx
jb     25aa <decode_feature+0x143a>
jmp    26dd <decode_feature+0x156d>
lea    0xf4d(%rip),%rax
movslq (%rax,%rcx,4),%rbx
add    %rax,%rbx
lea    0x1122(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4(%r12),%r8d
mov    %r8d,%esi
shr    $0x4,%esi
and    $0x1,%esi
mov    %r8d,%edx
shr    $0x3,%edx
and    $0x1,%edx
mov    %r8d,%ecx
shr    $0x2,%ecx
and    $0x1,%ecx
and    $0x1,%r8d
lea    0x1109(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
jmp    26dd <decode_feature+0x156d>
cmp    $0xffff,%ecx
jne    2683 <decode_feature+0x1513>
lea    0xfeb(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xfc9(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xf84(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xf8c(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xf8e(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xf93(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xf95(%rip),%r14
jmp    269c <decode_feature+0x152c>
lea    0xf99(%rip),%r14
jmp    269c <decode_feature+0x152c>
mov    %rsp,%r14
lea    0xfae(%rip),%rdx
mov    $0x80,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <snprintf@plt>
lea    0xf9f(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x9,%r15d
jb     26d3 <decode_feature+0x1563>
movzbl 0x8(%r12),%edx
mov    %edx,%esi
shr    %esi
and    $0x1,%esi
and    $0x1,%edx
lea    0xf9e(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
jmp    26dd <decode_feature+0x156d>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [1 x i8] zeroinitializer
@.str.1 = [47 x i8] c" version=%d, persist=%d, current=%d [0x%x]\0A\00"
@.str.2 = [64 x i8] c" available profiles [more recent typically higher in list]:\0A\00"
@.str.3 = [33 x i8] c" profile: %s , currentP=%d\0A\00"
@.str.4 = [40 x i8] c" additional length [%d] too short\0A\00"
@.str.5 = [12 x i8] c"unspecified\00"
@.str.6 = [12 x i8] c"SCSI family\00"
@.str.7 = [6 x i8] c"ATAPI\00"
@.str.8 = [17 x i8] c"IEEE 1394 - 1995\00"
@.str.9 = [11 x i8] c"IEEE 1394A\00"
@.str.10 = [14 x i8] c"Fibre channel\00"
@.str.11 = [11 x i8] c"IEEE 1394B\00"
@.str.12 = [13 x i8] c"Serial ATAPI\00"
@.str.13 = [19 x i8] c"USB (both 1 and 2)\00"
@.str.14 = [14 x i8] c"vendor unique\00"
@.str.15 = [7 x i8] c"[0x%x]\00"
@.str.16 = [38 x i8] c" Physical interface standard: %s\00"
@.str.17 = [19 x i8] c", INQ2=%d, DBE=%d\0A\00"
@.str.18 = [2 x i8] c"\0A\00"
@.str.19 = [28 x i8] c" OCEvent=%d, ASYNC=%d\0A\00"
@.str.20 = [16 x i8] c"Caddy/slot type\00"
@.str.21 = [10 x i8] c"Tray type\00"
@.str.22 = [12 x i8] c"Pop-up type\00"
@.str.23 = [52 x i8] c"Embedded changer with individually changeable discs\00"
@.str.24 = [34 x i8] c"Embedded changer using a magazine\00"
@.str.25 = [29 x i8] c" Loading mechanism: %s\0A\00"
@.str.26 = [53 x i8] c" Load=%d, Eject=%d, Prevent jumper=%d, Lock=%d\0A\00"
@.str.27 = [42 x i8] c" DWP=%d, WDCB=%d, SPWP=%d, SSWPP=%d\0A\00"
@.str.28 = [53 x i8] c" Logical block size=0x%x, blocking=0x%x, PP=%d\0A\00"
@.str.29 = [39 x i8] c" DAP=%d, C2 flags=%d, CD-Text=%d\0A\00"
@.str.30 = [42 x i8] c" MULTI110=%d, Dual-RW=%d, Dual-R=%d\0A\00"
@.str.31 = [68 x i8] c" Last lba=0x%x, Logical block size=0x%x, blocking=0x%x, PP=%d\0A\00"
@.str.32 = [65 x i8] c" Data block types supported=0x%x, TRIO=%d, ARSV=%d, BUF=%d\0A\00"
@.str.33 = [31 x i8] c" Number of link sizes=%d\0A\00"
@.str.34 = [12 x i8] c" %d\0A\00"
@.str.35 = [62 x i8] c" BD-RE: RENoSA=%d, Expand=%d, QCert=%d, Cert=%d, FRF=%d\0A\00"
@.str.36 = [20 x i8] c" BD-R: RRM=%d\0A\00"
@.str.37 = [14 x i8] c" SSA=%d\0A\00"
@.str.38 = [43 x i8] c" DVD+Write=%d, DVD+Read=%d, Write=%d\0A\00"
@.str.39 = [73 x i8] c" DRT-DM=%d, number of DBI cache zones=0x%x, number of entries=0x%x\0A\00"
@.str.40 = [47 x i8] c" Write=%d, Quick start=%d, Close only=%d\0A\00"
@.str.41 = [16 x i8] c" Write=%d\0A\00"
@.str.42 = [51 x i8] c" DSDG=%d, DSDR=%d, Intermediate=%d, Blank=%d\0A\00"
@.str.43 = [54 x i8] c" BUF=%d, R-W raw=%d, R-W pack=%d, Test write=%d\0A\00"
@.str.44 = [57 x i8] c" CD-RW=%d, R-W sub-code=%d, Data type supported=%d\0A\00"
@.str.45 = [41 x i8] c" BUF=%d, SAO=%d, Raw MS=%d, Raw=%d\0A\00"
@.str.46 = [39 x i8] c" Test write=%d, CD-RW=%d, R-W=%d\0A\00"
@.str.47 = [37 x i8] c" Maximum cue sheet length=0x%x\0A\00"
@.str.48 = [51 x i8] c" BUF=%d, RDL=%d, Test write=%d, DVD-RW SL=%d\0A\00"
@.str.49 = [15 x i8] c" CLJB=%d\0A\00"
@.str.50 = [28 x i8] c" Buffer block size=%d\0A\00"
@.str.51 = [51 x i8] c" CD-RW media sub-type support (bitmask)=0x%x\0A\00"
@.str.52 = [47 x i8] c" write=%d, quick_start=%d, close_only=%d\0A\00"
@.str.53 = [16 x i8] c" write=%d\0A\00"
@.str.54 = [39 x i8] c" Bitmaps for BD-RE read support:\0A\00"
@.str.55 = [64 x i8] c" Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, Class 3=0x%x\0A\00"
@.str.56 = [38 x i8] c" Bitmaps for BD-R read support:\0A\00"
@.str.57 = [40 x i8] c" Bitmaps for BD-ROM read support:\0A\00"
@.str.58 = [15 x i8] c" SVNR=%d\0A\00"
@.str.59 = [40 x i8] c" Bitmaps for BD-RE write support:\0A\00"
@.str.60 = [39 x i8] c" Bitmaps for BD-R write support:\0A\00"
@.str.61 = [41 x i8] c" Bitmaps for BD-ROM write support:\0A\00"
@.str.62 = [34 x i8] c" HD DVD-R=%d, HD DVD-RAM=%d\0A\00"
@.str.63 = [14 x i8] c" BGP=%d\0A\00"
@.str.64 = [13 x i8] c" RI=%d\0A\00"
@.str.65 = [13 x i8] c" PP=%d\0A\00"
@.str.66 = [46 x i8] c" SCC=%d, SDP=%d, highest slot number=%d\0A\00"
@.str.67 = [58 x i8] c" Scan=%d, SCM=%d, SV=%d, number of volume levels=%d\0A\00"
@.str.68 = [13 x i8] c" M5=%d\0A\00"
@.str.69 = [34 x i8] c" Group 3=%d, unit length=%d\0A\00"
@.str.70 = [22 x i8] c" CSS version=%d\0A\00"
@.str.71 = [48 x i8] c" RBCB=%d, SCS=%d, MP2A=%d, WSPD=%d, SW=%d\0A\00"
@.str.72 = [31 x i8] c" Drive serial number: %s\0A\00"
@.str.73 = [28 x i8] c" Disc control blocks:\0A\00"
@.str.74 = [14 x i8] c" 0x%x\0A\00"
@.str.75 = [23 x i8] c" CPRM version=%d\0A\00"
@.str.76 = [41 x i8] c" %.2s%.2s/%.2s/%.2s %.2s:%.2s:%.2s\0A\00"
@.str.77 = [48 x i8] c" BNG=%d, Block count for binding nonce=%d\0A\00"
@.str.78 = [43 x i8] c" Number of AGIDs=%d, AACS version=%d\0A\00"
@.str.79 = [65 x i8] c" Maximum number of scrambled extent information entries=%d\0A\00"
@.str.80 = [65 x i8] c" BD CPS major:minor version number=%d:%d, max open SACs=%d\0A\00"
@.str.81 = [30 x i8] c" PSAU=%d, LOSPB=%d, ME=%d\0A\00"
@.str.82 = [24 x i8] c" Profile numbers:\0A\00"
@.str.83 = [63 x i8] c" Unknown feature [0x%x], version=%d persist=%d, current=%d\0A\00"
define void @decode_feature(i32 %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [128 x i8]
%12 = alloca i8*
store i32 %0, i32* %4
store i8* %1, i8** %5
store i32 %2, i32* %6
store i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i8** %12
%13 = load i32, i32* %4
switch i32 %13, label %3229 [
i32 0, label %14
i32 1, label %82
i32 2, label %182
i32 3, label %235
i32 4, label %326
i32 16, label %397
i32 29, label %474
i32 34, label %474
i32 38, label %474
i32 39, label %474
i32 53, label %474
i32 56, label %474
i32 66, label %474
i32 256, label %474
i32 265, label %474
i32 272, label %474
i32 275, label %474
i32 30, label %501
i32 31, label %563
i32 32, label %622
i32 33, label %722
i32 35, label %817
i32 36, label %908
i32 37, label %949
i32 40, label %1026
i32 41, label %1085
i32 42, label %1143
i32 43, label %1205
i32 44, label %1249
i32 45, label %1320
i32 46, label %1420
i32 47, label %1536
i32 51, label %1607
i32 52, label %1664
i32 55, label %1713
i32 58, label %1752
i32 59, label %1814
i32 64, label %1858
i32 65, label %2018
i32 80, label %2188
i32 81, label %2241
i32 82, label %2294
i32 128, label %2338
i32 257, label %2382
i32 258, label %2426
i32 259, label %2484
i32 260, label %2556
i32 261, label %2604
i32 262, label %2655
i32 263, label %2694
i32 264, label %2774
i32 266, label %2823
i32 267, label %2894
i32 268, label %2933
i32 269, label %2982
i32 270, label %3040
i32 288, label %3079
i32 322, label %3130
]
14: ; preds = %3
%15 = load i8*, i8** %5
%16 = getelementptr inbounds i8, i8* %15, i64 2
%17 = load i8, i8* %16
%18 = zext i8 %17 to i32
%19 = ashr i32 %18, 2
%20 = and i32 %19, 15
%21 = load i8*, i8** %5
%22 = getelementptr inbounds i8, i8* %21, i64 2
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = and i32 %24, 2
%26 = icmp ne i32 %25, 0
%27 = xor i1 %26, true
%28 = xor i1 %27, true
%29 = zext i1 %28 to i32
%30 = load i8*, i8** %5
%31 = getelementptr inbounds i8, i8* %30, i64 2
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = and i32 %33, 1
%35 = icmp ne i32 %34, 0
%36 = xor i1 %35, true
%37 = xor i1 %36, true
%38 = zext i1 %37 to i32
%39 = load i32, i32* %4
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %20, i32 %29, i32 %38, i32 %39)
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.2, i64 0, i64 0))
store i32 4, i32* %7
br label %42
42: ; preds = %78, %14
%43 = load i32, i32* %7
%44 = load i32, i32* %6
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %81
46: ; preds = %42
%47 = load i8*, i8** %5
%48 = load i32, i32* %7
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = shl i32 %52, 8
%54 = load i8*, i8** %5
%55 = load i32, i32* %7
%56 = add nsw i32 %55, 1
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %54, i64 %57
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = add nsw i32 %53, %60
store i32 %61, i32* %10
%62 = load i32, i32* %10
%63 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
%64 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @get_profile_str to i32 (i32, i8*, ...)*)(i32 %62, i8* %63)
%65 = load i8*, i8** %5
%66 = load i32, i32* %7
%67 = add nsw i32 %66, 2
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %65, i64 %68
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = and i32 %71, 1
%73 = icmp ne i32 %72, 0
%74 = xor i1 %73, true
%75 = xor i1 %74, true
%76 = zext i1 %75 to i32
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i32 %64, i32 %76)
br label %78
78: ; preds = %46
%79 = load i32, i32* %7
%80 = add nsw i32 %79, 4
store i32 %80, i32* %7
br label %42
81: ; preds = %42
br label %3259
82: ; preds = %3
%83 = load i8*, i8** %5
%84 = getelementptr inbounds i8, i8* %83, i64 2
%85 = load i8, i8* %84
%86 = zext i8 %85 to i32
%87 = ashr i32 %86, 2
%88 = and i32 %87, 15
%89 = load i8*, i8** %5
%90 = getelementptr inbounds i8, i8* %89, i64 2
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = and i32 %92, 2
%94 = icmp ne i32 %93, 0
%95 = xor i1 %94, true
%96 = xor i1 %95, true
%97 = zext i1 %96 to i32
%98 = load i8*, i8** %5
%99 = getelementptr inbounds i8, i8* %98, i64 2
%100 = load i8, i8* %99
%101 = zext i8 %100 to i32
%102 = and i32 %101, 1
%103 = icmp ne i32 %102, 0
%104 = xor i1 %103, true
%105 = xor i1 %104, true
%106 = zext i1 %105 to i32
%107 = load i32, i32* %4
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %88, i32 %97, i32 %106, i32 %107)
%109 = load i32, i32* %6
%110 = icmp slt i32 %109, 8
br i1 %110, label %111, label %115
111: ; preds = %82
%112 = load i32, i32* %6
%113 = sub nsw i32 %112, 4
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %113)
br label %3259
115: ; preds = %82
%116 = load i8*, i8** %5
%117 = getelementptr inbounds i8, i8* %116, i64 4
%118 = load i8, i8* %117
%119 = zext i8 %118 to i32
%120 = shl i32 %119, 24
%121 = load i8*, i8** %5
%122 = getelementptr inbounds i8, i8* %121, i64 5
%123 = load i8, i8* %122
%124 = zext i8 %123 to i32
%125 = shl i32 %124, 16
%126 = add nsw i32 %120, %125
%127 = load i8*, i8** %5
%128 = getelementptr inbounds i8, i8* %127, i64 6
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
%131 = shl i32 %130, 8
%132 = add nsw i32 %126, %131
%133 = load i8*, i8** %5
%134 = getelementptr inbounds i8, i8* %133, i64 7
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = add nsw i32 %132, %136
store i32 %137, i32* %8
%138 = load i32, i32* %8
switch i32 %138, label %149 [
i32 0, label %139
i32 1, label %140
i32 2, label %141
i32 3, label %142
i32 4, label %143
i32 5, label %144
i32 6, label %145
i32 7, label %146
i32 8, label %147
i32 65535, label %148
]
139: ; preds = %115
store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0), i8** %12
br label %154
140: ; preds = %115
store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i8** %12
br label %154
141: ; preds = %115
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8** %12
br label %154
142: ; preds = %115
store i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), i8** %12
br label %154
143: ; preds = %115
store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.9, i64 0, i64 0), i8** %12
br label %154
144: ; preds = %115
store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.10, i64 0, i64 0), i8** %12
br label %154
145: ; preds = %115
store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i64 0, i64 0), i8** %12
br label %154
146: ; preds = %115
store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.12, i64 0, i64 0), i8** %12
br label %154
147: ; preds = %115
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.13, i64 0, i64 0), i8** %12
br label %154
148: ; preds = %115
store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.14, i64 0, i64 0), i8** %12
br label %154
149: ; preds = %115
%150 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
%151 = load i32, i32* %8
%152 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %150, i64 128, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i32 %151)
%153 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
store i8* %153, i8** %12
br label %154
154: ; preds = %149, %148, %147, %146, %145, %144, %143, %142, %141, %140, %139
%155 = load i8*, i8** %12
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.16, i64 0, i64 0), i8* %155)
%157 = load i32, i32* %6
%158 = icmp sgt i32 %157, 8
br i1 %158, label %159, label %179
159: ; preds = %154
%160 = load i8*, i8** %5
%161 = getelementptr inbounds i8, i8* %160, i64 8
%162 = load i8, i8* %161
%163 = zext i8 %162 to i32
%164 = and i32 %163, 2
%165 = icmp ne i32 %164, 0
%166 = xor i1 %165, true
%167 = xor i1 %166, true
%168 = zext i1 %167 to i32
%169 = load i8*, i8** %5
%170 = getelementptr inbounds i8, i8* %169, i64 8
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = and i32 %172, 1
%174 = icmp ne i32 %173, 0
%175 = xor i1 %174, true
%176 = xor i1 %175, true
%177 = zext i1 %176 to i32
%178 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i64 0, i64 0), i32 %168, i32 %177)
br label %181
179: ; preds = %154
%180 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
br label %181
181: ; preds = %179, %159
br label %3259
182: ; preds = %3
%183 = load i8*, i8** %5
%184 = getelementptr inbounds i8, i8* %183, i64 2
%185 = load i8, i8* %184
%186 = zext i8 %185 to i32
%187 = ashr i32 %186, 2
%188 = and i32 %187, 15
%189 = load i8*, i8** %5
%190 = getelementptr inbounds i8, i8* %189, i64 2
%191 = load i8, i8* %190
%192 = zext i8 %191 to i32
%193 = and i32 %192, 2
%194 = icmp ne i32 %193, 0
%195 = xor i1 %194, true
%196 = xor i1 %195, true
%197 = zext i1 %196 to i32
%198 = load i8*, i8** %5
%199 = getelementptr inbounds i8, i8* %198, i64 2
%200 = load i8, i8* %199
%201 = zext i8 %200 to i32
%202 = and i32 %201, 1
%203 = icmp ne i32 %202, 0
%204 = xor i1 %203, true
%205 = xor i1 %204, true
%206 = zext i1 %205 to i32
%207 = load i32, i32* %4
%208 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %188, i32 %197, i32 %206, i32 %207)
%209 = load i32, i32* %6
%210 = icmp slt i32 %209, 8
br i1 %210, label %211, label %215
211: ; preds = %182
%212 = load i32, i32* %6
%213 = sub nsw i32 %212, 4
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %213)
br label %3259
215: ; preds = %182
%216 = load i8*, i8** %5
%217 = getelementptr inbounds i8, i8* %216, i64 4
%218 = load i8, i8* %217
%219 = zext i8 %218 to i32
%220 = and i32 %219, 2
%221 = icmp ne i32 %220, 0
%222 = xor i1 %221, true
%223 = xor i1 %222, true
%224 = zext i1 %223 to i32
%225 = load i8*, i8** %5
%226 = getelementptr inbounds i8, i8* %225, i64 4
%227 = load i8, i8* %226
%228 = zext i8 %227 to i32
%229 = and i32 %228, 1
%230 = icmp ne i32 %229, 0
%231 = xor i1 %230, true
%232 = xor i1 %231, true
%233 = zext i1 %232 to i32
%234 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.19, i64 0, i64 0), i32 %224, i32 %233)
br label %3259
235: ; preds = %3
%236 = load i8*, i8** %5
%237 = getelementptr inbounds i8, i8* %236, i64 2
%238 = load i8, i8* %237
%239 = zext i8 %238 to i32
%240 = ashr i32 %239, 2
%241 = and i32 %240, 15
%242 = load i8*, i8** %5
%243 = getelementptr inbounds i8, i8* %242, i64 2
%244 = load i8, i8* %243
%245 = zext i8 %244 to i32
%246 = and i32 %245, 2
%247 = icmp ne i32 %246, 0
%248 = xor i1 %247, true
%249 = xor i1 %248, true
%250 = zext i1 %249 to i32
%251 = load i8*, i8** %5
%252 = getelementptr inbounds i8, i8* %251, i64 2
%253 = load i8, i8* %252
%254 = zext i8 %253 to i32
%255 = and i32 %254, 1
%256 = icmp ne i32 %255, 0
%257 = xor i1 %256, true
%258 = xor i1 %257, true
%259 = zext i1 %258 to i32
%260 = load i32, i32* %4
%261 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %241, i32 %250, i32 %259, i32 %260)
%262 = load i32, i32* %6
%263 = icmp slt i32 %262, 8
br i1 %263, label %264, label %268
264: ; preds = %235
%265 = load i32, i32* %6
%266 = sub nsw i32 %265, 4
%267 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %266)
br label %3259
268: ; preds = %235
%269 = load i8*, i8** %5
%270 = getelementptr inbounds i8, i8* %269, i64 4
%271 = load i8, i8* %270
%272 = zext i8 %271 to i32
%273 = ashr i32 %272, 5
%274 = and i32 %273, 7
store i32 %274, i32* %8
%275 = load i32, i32* %8
switch i32 %275, label %281 [
i32 0, label %276
i32 1, label %277
i32 2, label %278
i32 4, label %279
i32 5, label %280
]
276: ; preds = %268
store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.20, i64 0, i64 0), i8** %12
br label %286
277: ; preds = %268
store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.21, i64 0, i64 0), i8** %12
br label %286
278: ; preds = %268
store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.22, i64 0, i64 0), i8** %12
br label %286
279: ; preds = %268
store i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.23, i64 0, i64 0), i8** %12
br label %286
280: ; preds = %268
store i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.24, i64 0, i64 0), i8** %12
br label %286
281: ; preds = %268
%282 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
%283 = load i32, i32* %8
%284 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %282, i64 128, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i32 %283)
%285 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
store i8* %285, i8** %12
br label %286
286: ; preds = %281, %280, %279, %278, %277, %276
%287 = load i8*, i8** %12
%288 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.25, i64 0, i64 0), i8* %287)
%289 = load i8*, i8** %5
%290 = getelementptr inbounds i8, i8* %289, i64 4
%291 = load i8, i8* %290
%292 = zext i8 %291 to i32
%293 = and i32 %292, 16
%294 = icmp ne i32 %293, 0
%295 = xor i1 %294, true
%296 = xor i1 %295, true
%297 = zext i1 %296 to i32
%298 = load i8*, i8** %5
%299 = getelementptr inbounds i8, i8* %298, i64 4
%300 = load i8, i8* %299
%301 = zext i8 %300 to i32
%302 = and i32 %301, 8
%303 = icmp ne i32 %302, 0
%304 = xor i1 %303, true
%305 = xor i1 %304, true
%306 = zext i1 %305 to i32
%307 = load i8*, i8** %5
%308 = getelementptr inbounds i8, i8* %307, i64 4
%309 = load i8, i8* %308
%310 = zext i8 %309 to i32
%311 = and i32 %310, 4
%312 = icmp ne i32 %311, 0
%313 = xor i1 %312, true
%314 = xor i1 %313, true
%315 = zext i1 %314 to i32
%316 = load i8*, i8** %5
%317 = getelementptr inbounds i8, i8* %316, i64 4
%318 = load i8, i8* %317
%319 = zext i8 %318 to i32
%320 = and i32 %319, 1
%321 = icmp ne i32 %320, 0
%322 = xor i1 %321, true
%323 = xor i1 %322, true
%324 = zext i1 %323 to i32
%325 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.26, i64 0, i64 0), i32 %297, i32 %306, i32 %315, i32 %324)
br label %3259
326: ; preds = %3
%327 = load i8*, i8** %5
%328 = getelementptr inbounds i8, i8* %327, i64 2
%329 = load i8, i8* %328
%330 = zext i8 %329 to i32
%331 = ashr i32 %330, 2
%332 = and i32 %331, 15
%333 = load i8*, i8** %5
%334 = getelementptr inbounds i8, i8* %333, i64 2
%335 = load i8, i8* %334
%336 = zext i8 %335 to i32
%337 = and i32 %336, 2
%338 = icmp ne i32 %337, 0
%339 = xor i1 %338, true
%340 = xor i1 %339, true
%341 = zext i1 %340 to i32
%342 = load i8*, i8** %5
%343 = getelementptr inbounds i8, i8* %342, i64 2
%344 = load i8, i8* %343
%345 = zext i8 %344 to i32
%346 = and i32 %345, 1
%347 = icmp ne i32 %346, 0
%348 = xor i1 %347, true
%349 = xor i1 %348, true
%350 = zext i1 %349 to i32
%351 = load i32, i32* %4
%352 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %332, i32 %341, i32 %350, i32 %351)
%353 = load i32, i32* %6
%354 = icmp slt i32 %353, 8
br i1 %354, label %355, label %359
355: ; preds = %326
%356 = load i32, i32* %6
%357 = sub nsw i32 %356, 4
%358 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %357)
br label %3259
359: ; preds = %326
%360 = load i8*, i8** %5
%361 = getelementptr inbounds i8, i8* %360, i64 4
%362 = load i8, i8* %361
%363 = zext i8 %362 to i32
%364 = and i32 %363, 8
%365 = icmp ne i32 %364, 0
%366 = xor i1 %365, true
%367 = xor i1 %366, true
%368 = zext i1 %367 to i32
%369 = load i8*, i8** %5
%370 = getelementptr inbounds i8, i8* %369, i64 4
%371 = load i8, i8* %370
%372 = zext i8 %371 to i32
%373 = and i32 %372, 4
%374 = icmp ne i32 %373, 0
%375 = xor i1 %374, true
%376 = xor i1 %375, true
%377 = zext i1 %376 to i32
%378 = load i8*, i8** %5
%379 = getelementptr inbounds i8, i8* %378, i64 4
%380 = load i8, i8* %379
%381 = zext i8 %380 to i32
%382 = and i32 %381, 2
%383 = icmp ne i32 %382, 0
%384 = xor i1 %383, true
%385 = xor i1 %384, true
%386 = zext i1 %385 to i32
%387 = load i8*, i8** %5
%388 = getelementptr inbounds i8, i8* %387, i64 4
%389 = load i8, i8* %388
%390 = zext i8 %389 to i32
%391 = and i32 %390, 1
%392 = icmp ne i32 %391, 0
%393 = xor i1 %392, true
%394 = xor i1 %393, true
%395 = zext i1 %394 to i32
%396 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.27, i64 0, i64 0), i32 %368, i32 %377, i32 %386, i32 %395)
br label %3259
397: ; preds = %3
%398 = load i8*, i8** %5
%399 = getelementptr inbounds i8, i8* %398, i64 2
%400 = load i8, i8* %399
%401 = zext i8 %400 to i32
%402 = ashr i32 %401, 2
%403 = and i32 %402, 15
%404 = load i8*, i8** %5
%405 = getelementptr inbounds i8, i8* %404, i64 2
%406 = load i8, i8* %405
%407 = zext i8 %406 to i32
%408 = and i32 %407, 2
%409 = icmp ne i32 %408, 0
%410 = xor i1 %409, true
%411 = xor i1 %410, true
%412 = zext i1 %411 to i32
%413 = load i8*, i8** %5
%414 = getelementptr inbounds i8, i8* %413, i64 2
%415 = load i8, i8* %414
%416 = zext i8 %415 to i32
%417 = and i32 %416, 1
%418 = icmp ne i32 %417, 0
%419 = xor i1 %418, true
%420 = xor i1 %419, true
%421 = zext i1 %420 to i32
%422 = load i32, i32* %4
%423 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %403, i32 %412, i32 %421, i32 %422)
%424 = load i32, i32* %6
%425 = icmp slt i32 %424, 12
br i1 %425, label %426, label %430
426: ; preds = %397
%427 = load i32, i32* %6
%428 = sub nsw i32 %427, 4
%429 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %428)
br label %3259
430: ; preds = %397
%431 = load i8*, i8** %5
%432 = getelementptr inbounds i8, i8* %431, i64 4
%433 = load i8, i8* %432
%434 = zext i8 %433 to i32
%435 = shl i32 %434, 24
%436 = load i8*, i8** %5
%437 = getelementptr inbounds i8, i8* %436, i64 5
%438 = load i8, i8* %437
%439 = zext i8 %438 to i32
%440 = shl i32 %439, 16
%441 = add nsw i32 %435, %440
%442 = load i8*, i8** %5
%443 = getelementptr inbounds i8, i8* %442, i64 6
%444 = load i8, i8* %443
%445 = zext i8 %444 to i32
%446 = shl i32 %445, 8
%447 = add nsw i32 %441, %446
%448 = load i8*, i8** %5
%449 = getelementptr inbounds i8, i8* %448, i64 7
%450 = load i8, i8* %449
%451 = zext i8 %450 to i32
%452 = add nsw i32 %447, %451
store i32 %452, i32* %8
%453 = load i32, i32* %8
%454 = load i8*, i8** %5
%455 = getelementptr inbounds i8, i8* %454, i64 8
%456 = load i8, i8* %455
%457 = zext i8 %456 to i32
%458 = shl i32 %457, 8
%459 = load i8*, i8** %5
%460 = getelementptr inbounds i8, i8* %459, i64 9
%461 = load i8, i8* %460
%462 = zext i8 %461 to i32
%463 = add nsw i32 %458, %462
%464 = load i8*, i8** %5
%465 = getelementptr inbounds i8, i8* %464, i64 10
%466 = load i8, i8* %465
%467 = zext i8 %466 to i32
%468 = and i32 %467, 1
%469 = icmp ne i32 %468, 0
%470 = xor i1 %469, true
%471 = xor i1 %470, true
%472 = zext i1 %471 to i32
%473 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.28, i64 0, i64 0), i32 %453, i32 %463, i32 %472)
br label %3259
474: ; preds = %3, %3, %3, %3, %3, %3, %3, %3, %3, %3, %3
%475 = load i8*, i8** %5
%476 = getelementptr inbounds i8, i8* %475, i64 2
%477 = load i8, i8* %476
%478 = zext i8 %477 to i32
%479 = ashr i32 %478, 2
%480 = and i32 %479, 15
%481 = load i8*, i8** %5
%482 = getelementptr inbounds i8, i8* %481, i64 2
%483 = load i8, i8* %482
%484 = zext i8 %483 to i32
%485 = and i32 %484, 2
%486 = icmp ne i32 %485, 0
%487 = xor i1 %486, true
%488 = xor i1 %487, true
%489 = zext i1 %488 to i32
%490 = load i8*, i8** %5
%491 = getelementptr inbounds i8, i8* %490, i64 2
%492 = load i8, i8* %491
%493 = zext i8 %492 to i32
%494 = and i32 %493, 1
%495 = icmp ne i32 %494, 0
%496 = xor i1 %495, true
%497 = xor i1 %496, true
%498 = zext i1 %497 to i32
%499 = load i32, i32* %4
%500 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %480, i32 %489, i32 %498, i32 %499)
br label %3259
501: ; preds = %3
%502 = load i8*, i8** %5
%503 = getelementptr inbounds i8, i8* %502, i64 2
%504 = load i8, i8* %503
%505 = zext i8 %504 to i32
%506 = ashr i32 %505, 2
%507 = and i32 %506, 15
%508 = load i8*, i8** %5
%509 = getelementptr inbounds i8, i8* %508, i64 2
%510 = load i8, i8* %509
%511 = zext i8 %510 to i32
%512 = and i32 %511, 2
%513 = icmp ne i32 %512, 0
%514 = xor i1 %513, true
%515 = xor i1 %514, true
%516 = zext i1 %515 to i32
%517 = load i8*, i8** %5
%518 = getelementptr inbounds i8, i8* %517, i64 2
%519 = load i8, i8* %518
%520 = zext i8 %519 to i32
%521 = and i32 %520, 1
%522 = icmp ne i32 %521, 0
%523 = xor i1 %522, true
%524 = xor i1 %523, true
%525 = zext i1 %524 to i32
%526 = load i32, i32* %4
%527 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %507, i32 %516, i32 %525, i32 %526)
%528 = load i32, i32* %6
%529 = icmp slt i32 %528, 8
br i1 %529, label %530, label %534
530: ; preds = %501
%531 = load i32, i32* %6
%532 = sub nsw i32 %531, 4
%533 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %532)
br label %3259
534: ; preds = %501
%535 = load i8*, i8** %5
%536 = getelementptr inbounds i8, i8* %535, i64 4
%537 = load i8, i8* %536
%538 = zext i8 %537 to i32
%539 = and i32 %538, 128
%540 = icmp ne i32 %539, 0
%541 = xor i1 %540, true
%542 = xor i1 %541, true
%543 = zext i1 %542 to i32
%544 = load i8*, i8** %5
%545 = getelementptr inbounds i8, i8* %544, i64 4
%546 = load i8, i8* %545
%547 = zext i8 %546 to i32
%548 = and i32 %547, 2
%549 = icmp ne i32 %548, 0
%550 = xor i1 %549, true
%551 = xor i1 %550, true
%552 = zext i1 %551 to i32
%553 = load i8*, i8** %5
%554 = getelementptr inbounds i8, i8* %553, i64 4
%555 = load i8, i8* %554
%556 = zext i8 %555 to i32
%557 = and i32 %556, 1
%558 = icmp ne i32 %557, 0
%559 = xor i1 %558, true
%560 = xor i1 %559, true
%561 = zext i1 %560 to i32
%562 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.29, i64 0, i64 0), i32 %543, i32 %552, i32 %561)
br label %3259
563: ; preds = %3
%564 = load i8*, i8** %5
%565 = getelementptr inbounds i8, i8* %564, i64 2
%566 = load i8, i8* %565
%567 = zext i8 %566 to i32
%568 = ashr i32 %567, 2
%569 = and i32 %568, 15
%570 = load i8*, i8** %5
%571 = getelementptr inbounds i8, i8* %570, i64 2
%572 = load i8, i8* %571
%573 = zext i8 %572 to i32
%574 = and i32 %573, 2
%575 = icmp ne i32 %574, 0
%576 = xor i1 %575, true
%577 = xor i1 %576, true
%578 = zext i1 %577 to i32
%579 = load i8*, i8** %5
%580 = getelementptr inbounds i8, i8* %579, i64 2
%581 = load i8, i8* %580
%582 = zext i8 %581 to i32
%583 = and i32 %582, 1
%584 = icmp ne i32 %583, 0
%585 = xor i1 %584, true
%586 = xor i1 %585, true
%587 = zext i1 %586 to i32
%588 = load i32, i32* %4
%589 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %569, i32 %578, i32 %587, i32 %588)
%590 = load i32, i32* %6
%591 = icmp sgt i32 %590, 7
br i1 %591, label %592, label %621
592: ; preds = %563
%593 = load i8*, i8** %5
%594 = getelementptr inbounds i8, i8* %593, i64 4
%595 = load i8, i8* %594
%596 = zext i8 %595 to i32
%597 = and i32 %596, 1
%598 = icmp ne i32 %597, 0
%599 = xor i1 %598, true
%600 = xor i1 %599, true
%601 = zext i1 %600 to i32
%602 = load i8*, i8** %5
%603 = getelementptr inbounds i8, i8* %602, i64 6
%604 = load i8, i8* %603
%605 = zext i8 %604 to i32
%606 = and i32 %605, 2
%607 = icmp ne i32 %606, 0
%608 = xor i1 %607, true
%609 = xor i1 %608, true
%610 = zext i1 %609 to i32
%611 = load i8*, i8** %5
%612 = getelementptr inbounds i8, i8* %611, i64 6
%613 = load i8, i8* %612
%614 = zext i8 %613 to i32
%615 = and i32 %614, 1
%616 = icmp ne i32 %615, 0
%617 = xor i1 %616, true
%618 = xor i1 %617, true
%619 = zext i1 %618 to i32
%620 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.30, i64 0, i64 0), i32 %601, i32 %610, i32 %619)
br label %621
621: ; preds = %592, %563
br label %3259
622: ; preds = %3
%623 = load i8*, i8** %5
%624 = getelementptr inbounds i8, i8* %623, i64 2
%625 = load i8, i8* %624
%626 = zext i8 %625 to i32
%627 = ashr i32 %626, 2
%628 = and i32 %627, 15
%629 = load i8*, i8** %5
%630 = getelementptr inbounds i8, i8* %629, i64 2
%631 = load i8, i8* %630
%632 = zext i8 %631 to i32
%633 = and i32 %632, 2
%634 = icmp ne i32 %633, 0
%635 = xor i1 %634, true
%636 = xor i1 %635, true
%637 = zext i1 %636 to i32
%638 = load i8*, i8** %5
%639 = getelementptr inbounds i8, i8* %638, i64 2
%640 = load i8, i8* %639
%641 = zext i8 %640 to i32
%642 = and i32 %641, 1
%643 = icmp ne i32 %642, 0
%644 = xor i1 %643, true
%645 = xor i1 %644, true
%646 = zext i1 %645 to i32
%647 = load i32, i32* %4
%648 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %628, i32 %637, i32 %646, i32 %647)
%649 = load i32, i32* %6
%650 = icmp slt i32 %649, 16
br i1 %650, label %651, label %655
651: ; preds = %622
%652 = load i32, i32* %6
%653 = sub nsw i32 %652, 4
%654 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %653)
br label %3259
655: ; preds = %622
%656 = load i8*, i8** %5
%657 = getelementptr inbounds i8, i8* %656, i64 4
%658 = load i8, i8* %657
%659 = zext i8 %658 to i32
%660 = shl i32 %659, 24
%661 = load i8*, i8** %5
%662 = getelementptr inbounds i8, i8* %661, i64 5
%663 = load i8, i8* %662
%664 = zext i8 %663 to i32
%665 = shl i32 %664, 16
%666 = add nsw i32 %660, %665
%667 = load i8*, i8** %5
%668 = getelementptr inbounds i8, i8* %667, i64 6
%669 = load i8, i8* %668
%670 = zext i8 %669 to i32
%671 = shl i32 %670, 8
%672 = add nsw i32 %666, %671
%673 = load i8*, i8** %5
%674 = getelementptr inbounds i8, i8* %673, i64 7
%675 = load i8, i8* %674
%676 = zext i8 %675 to i32
%677 = add nsw i32 %672, %676
store i32 %677, i32* %8
%678 = load i8*, i8** %5
%679 = getelementptr inbounds i8, i8* %678, i64 8
%680 = load i8, i8* %679
%681 = zext i8 %680 to i32
%682 = shl i32 %681, 24
%683 = load i8*, i8** %5
%684 = getelementptr inbounds i8, i8* %683, i64 9
%685 = load i8, i8* %684
%686 = zext i8 %685 to i32
%687 = shl i32 %686, 16
%688 = add nsw i32 %682, %687
%689 = load i8*, i8** %5
%690 = getelementptr inbounds i8, i8* %689, i64 10
%691 = load i8, i8* %690
%692 = zext i8 %691 to i32
%693 = shl i32 %692, 8
%694 = add nsw i32 %688, %693
%695 = load i8*, i8** %5
%696 = getelementptr inbounds i8, i8* %695, i64 11
%697 = load i8, i8* %696
%698 = zext i8 %697 to i32
%699 = add nsw i32 %694, %698
store i32 %699, i32* %9
%700 = load i32, i32* %8
%701 = load i32, i32* %9
%702 = load i8*, i8** %5
%703 = getelementptr inbounds i8, i8* %702, i64 12
%704 = load i8, i8* %703
%705 = zext i8 %704 to i32
%706 = shl i32 %705, 8
%707 = load i8*, i8** %5
%708 = getelementptr inbounds i8, i8* %707, i64 13
%709 = load i8, i8* %708
%710 = zext i8 %709 to i32
%711 = add nsw i32 %706, %710
%712 = load i8*, i8** %5
%713 = getelementptr inbounds i8, i8* %712, i64 14
%714 = load i8, i8* %713
%715 = zext i8 %714 to i32
%716 = and i32 %715, 1
%717 = icmp ne i32 %716, 0
%718 = xor i1 %717, true
%719 = xor i1 %718, true
%720 = zext i1 %719 to i32
%721 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.31, i64 0, i64 0), i32 %700, i32 %701, i32 %711, i32 %720)
br label %3259
722: ; preds = %3
%723 = load i8*, i8** %5
%724 = getelementptr inbounds i8, i8* %723, i64 2
%725 = load i8, i8* %724
%726 = zext i8 %725 to i32
%727 = ashr i32 %726, 2
%728 = and i32 %727, 15
%729 = load i8*, i8** %5
%730 = getelementptr inbounds i8, i8* %729, i64 2
%731 = load i8, i8* %730
%732 = zext i8 %731 to i32
%733 = and i32 %732, 2
%734 = icmp ne i32 %733, 0
%735 = xor i1 %734, true
%736 = xor i1 %735, true
%737 = zext i1 %736 to i32
%738 = load i8*, i8** %5
%739 = getelementptr inbounds i8, i8* %738, i64 2
%740 = load i8, i8* %739
%741 = zext i8 %740 to i32
%742 = and i32 %741, 1
%743 = icmp ne i32 %742, 0
%744 = xor i1 %743, true
%745 = xor i1 %744, true
%746 = zext i1 %745 to i32
%747 = load i32, i32* %4
%748 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %728, i32 %737, i32 %746, i32 %747)
%749 = load i32, i32* %6
%750 = icmp slt i32 %749, 8
br i1 %750, label %751, label %755
751: ; preds = %722
%752 = load i32, i32* %6
%753 = sub nsw i32 %752, 4
%754 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %753)
br label %3259
755: ; preds = %722
%756 = load i8*, i8** %5
%757 = getelementptr inbounds i8, i8* %756, i64 4
%758 = load i8, i8* %757
%759 = zext i8 %758 to i32
%760 = shl i32 %759, 8
%761 = load i8*, i8** %5
%762 = getelementptr inbounds i8, i8* %761, i64 5
%763 = load i8, i8* %762
%764 = zext i8 %763 to i32
%765 = add nsw i32 %760, %764
%766 = load i8*, i8** %5
%767 = getelementptr inbounds i8, i8* %766, i64 6
%768 = load i8, i8* %767
%769 = zext i8 %768 to i32
%770 = and i32 %769, 4
%771 = icmp ne i32 %770, 0
%772 = xor i1 %771, true
%773 = xor i1 %772, true
%774 = zext i1 %773 to i32
%775 = load i8*, i8** %5
%776 = getelementptr inbounds i8, i8* %775, i64 6
%777 = load i8, i8* %776
%778 = zext i8 %777 to i32
%779 = and i32 %778, 2
%780 = icmp ne i32 %779, 0
%781 = xor i1 %780, true
%782 = xor i1 %781, true
%783 = zext i1 %782 to i32
%784 = load i8*, i8** %5
%785 = getelementptr inbounds i8, i8* %784, i64 6
%786 = load i8, i8* %785
%787 = zext i8 %786 to i32
%788 = and i32 %787, 1
%789 = icmp ne i32 %788, 0
%790 = xor i1 %789, true
%791 = xor i1 %790, true
%792 = zext i1 %791 to i32
%793 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.32, i64 0, i64 0), i32 %765, i32 %774, i32 %783, i32 %792)
%794 = load i8*, i8** %5
%795 = getelementptr inbounds i8, i8* %794, i64 7
%796 = load i8, i8* %795
%797 = zext i8 %796 to i32
store i32 %797, i32* %8
%798 = load i32, i32* %8
%799 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.33, i64 0, i64 0), i32 %798)
store i32 0, i32* %7
br label %800
800: ; preds = %813, %755
%801 = load i32, i32* %7
%802 = load i32, i32* %8
%803 = icmp slt i32 %801, %802
br i1 %803, label %804, label %816
804: ; preds = %800
%805 = load i8*, i8** %5
%806 = load i32, i32* %7
%807 = add nsw i32 8, %806
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds i8, i8* %805, i64 %808
%810 = load i8, i8* %809
%811 = zext i8 %810 to i32
%812 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.34, i64 0, i64 0), i32 %811)
br label %813
813: ; preds = %804
%814 = load i32, i32* %7
%815 = add nsw i32 %814, 1
store i32 %815, i32* %7
br label %800
816: ; preds = %800
br label %3259
817: ; preds = %3
%818 = load i8*, i8** %5
%819 = getelementptr inbounds i8, i8* %818, i64 2
%820 = load i8, i8* %819
%821 = zext i8 %820 to i32
%822 = ashr i32 %821, 2
%823 = and i32 %822, 15
%824 = load i8*, i8** %5
%825 = getelementptr inbounds i8, i8* %824, i64 2
%826 = load i8, i8* %825
%827 = zext i8 %826 to i32
%828 = and i32 %827, 2
%829 = icmp ne i32 %828, 0
%830 = xor i1 %829, true
%831 = xor i1 %830, true
%832 = zext i1 %831 to i32
%833 = load i8*, i8** %5
%834 = getelementptr inbounds i8, i8* %833, i64 2
%835 = load i8, i8* %834
%836 = zext i8 %835 to i32
%837 = and i32 %836, 1
%838 = icmp ne i32 %837, 0
%839 = xor i1 %838, true
%840 = xor i1 %839, true
%841 = zext i1 %840 to i32
%842 = load i32, i32* %4
%843 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %823, i32 %832, i32 %841, i32 %842)
%844 = load i32, i32* %6
%845 = icmp sgt i32 %844, 4
br i1 %845, label %846, label %893
846: ; preds = %817
%847 = load i8*, i8** %5
%848 = getelementptr inbounds i8, i8* %847, i64 4
%849 = load i8, i8* %848
%850 = zext i8 %849 to i32
%851 = and i32 %850, 8
%852 = icmp ne i32 %851, 0
%853 = xor i1 %852, true
%854 = xor i1 %853, true
%855 = zext i1 %854 to i32
%856 = load i8*, i8** %5
%857 = getelementptr inbounds i8, i8* %856, i64 4
%858 = load i8, i8* %857
%859 = zext i8 %858 to i32
%860 = and i32 %859, 4
%861 = icmp ne i32 %860, 0
%862 = xor i1 %861, true
%863 = xor i1 %862, true
%864 = zext i1 %863 to i32
%865 = load i8*, i8** %5
%866 = getelementptr inbounds i8, i8* %865, i64 4
%867 = load i8, i8* %866
%868 = zext i8 %867 to i32
%869 = and i32 %868, 2
%870 = icmp ne i32 %869, 0
%871 = xor i1 %870, true
%872 = xor i1 %871, true
%873 = zext i1 %872 to i32
%874 = load i8*, i8** %5
%875 = getelementptr inbounds i8, i8* %874, i64 4
%876 = load i8, i8* %875
%877 = zext i8 %876 to i32
%878 = and i32 %877, 1
%879 = icmp ne i32 %878, 0
%880 = xor i1 %879, true
%881 = xor i1 %880, true
%882 = zext i1 %881 to i32
%883 = load i8*, i8** %5
%884 = getelementptr inbounds i8, i8* %883, i64 5
%885 = load i8, i8* %884
%886 = zext i8 %885 to i32
%887 = and i32 %886, 128
%888 = icmp ne i32 %887, 0
%889 = xor i1 %888, true
%890 = xor i1 %889, true
%891 = zext i1 %890 to i32
%892 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.35, i64 0, i64 0), i32 %855, i32 %864, i32 %873, i32 %882, i32 %891)
br label %893
893: ; preds = %846, %817
%894 = load i32, i32* %6
%895 = icmp sgt i32 %894, 8
br i1 %895, label %896, label %907
896: ; preds = %893
%897 = load i8*, i8** %5
%898 = getelementptr inbounds i8, i8* %897, i64 8
%899 = load i8, i8* %898
%900 = zext i8 %899 to i32
%901 = and i32 %900, 1
%902 = icmp ne i32 %901, 0
%903 = xor i1 %902, true
%904 = xor i1 %903, true
%905 = zext i1 %904 to i32
%906 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.36, i64 0, i64 0), i32 %905)
br label %907
907: ; preds = %896, %893
br label %3259
908: ; preds = %3
%909 = load i8*, i8** %5
%910 = getelementptr inbounds i8, i8* %909, i64 2
%911 = load i8, i8* %910
%912 = zext i8 %911 to i32
%913 = ashr i32 %912, 2
%914 = and i32 %913, 15
%915 = load i8*, i8** %5
%916 = getelementptr inbounds i8, i8* %915, i64 2
%917 = load i8, i8* %916
%918 = zext i8 %917 to i32
%919 = and i32 %918, 2
%920 = icmp ne i32 %919, 0
%921 = xor i1 %920, true
%922 = xor i1 %921, true
%923 = zext i1 %922 to i32
%924 = load i8*, i8** %5
%925 = getelementptr inbounds i8, i8* %924, i64 2
%926 = load i8, i8* %925
%927 = zext i8 %926 to i32
%928 = and i32 %927, 1
%929 = icmp ne i32 %928, 0
%930 = xor i1 %929, true
%931 = xor i1 %930, true
%932 = zext i1 %931 to i32
%933 = load i32, i32* %4
%934 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %914, i32 %923, i32 %932, i32 %933)
%935 = load i32, i32* %6
%936 = icmp sgt i32 %935, 4
br i1 %936, label %937, label %948
937: ; preds = %908
%938 = load i8*, i8** %5
%939 = getelementptr inbounds i8, i8* %938, i64 4
%940 = load i8, i8* %939
%941 = zext i8 %940 to i32
%942 = and i32 %941, 128
%943 = icmp ne i32 %942, 0
%944 = xor i1 %943, true
%945 = xor i1 %944, true
%946 = zext i1 %945 to i32
%947 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.37, i64 0, i64 0), i32 %946)
br label %948
948: ; preds = %937, %908
br label %3259
949: ; preds = %3
%950 = load i8*, i8** %5
%951 = getelementptr inbounds i8, i8* %950, i64 2
%952 = load i8, i8* %951
%953 = zext i8 %952 to i32
%954 = ashr i32 %953, 2
%955 = and i32 %954, 15
%956 = load i8*, i8** %5
%957 = getelementptr inbounds i8, i8* %956, i64 2
%958 = load i8, i8* %957
%959 = zext i8 %958 to i32
%960 = and i32 %959, 2
%961 = icmp ne i32 %960, 0
%962 = xor i1 %961, true
%963 = xor i1 %962, true
%964 = zext i1 %963 to i32
%965 = load i8*, i8** %5
%966 = getelementptr inbounds i8, i8* %965, i64 2
%967 = load i8, i8* %966
%968 = zext i8 %967 to i32
%969 = and i32 %968, 1
%970 = icmp ne i32 %969, 0
%971 = xor i1 %970, true
%972 = xor i1 %971, true
%973 = zext i1 %972 to i32
%974 = load i32, i32* %4
%975 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %955, i32 %964, i32 %973, i32 %974)
%976 = load i32, i32* %6
%977 = icmp slt i32 %976, 12
br i1 %977, label %978, label %982
978: ; preds = %949
%979 = load i32, i32* %6
%980 = sub nsw i32 %979, 4
%981 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %980)
br label %3259
982: ; preds = %949
%983 = load i8*, i8** %5
%984 = getelementptr inbounds i8, i8* %983, i64 4
%985 = load i8, i8* %984
%986 = zext i8 %985 to i32
%987 = shl i32 %986, 24
%988 = load i8*, i8** %5
%989 = getelementptr inbounds i8, i8* %988, i64 5
%990 = load i8, i8* %989
%991 = zext i8 %990 to i32
%992 = shl i32 %991, 16
%993 = add nsw i32 %987, %992
%994 = load i8*, i8** %5
%995 = getelementptr inbounds i8, i8* %994, i64 6
%996 = load i8, i8* %995
%997 = zext i8 %996 to i32
%998 = shl i32 %997, 8
%999 = add nsw i32 %993, %998
%1000 = load i8*, i8** %5
%1001 = getelementptr inbounds i8, i8* %1000, i64 7
%1002 = load i8, i8* %1001
%1003 = zext i8 %1002 to i32
%1004 = add nsw i32 %999, %1003
store i32 %1004, i32* %8
%1005 = load i32, i32* %8
%1006 = load i8*, i8** %5
%1007 = getelementptr inbounds i8, i8* %1006, i64 8
%1008 = load i8, i8* %1007
%1009 = zext i8 %1008 to i32
%1010 = shl i32 %1009, 8
%1011 = load i8*, i8** %5
%1012 = getelementptr inbounds i8, i8* %1011, i64 9
%1013 = load i8, i8* %1012
%1014 = zext i8 %1013 to i32
%1015 = add nsw i32 %1010, %1014
%1016 = load i8*, i8** %5
%1017 = getelementptr inbounds i8, i8* %1016, i64 10
%1018 = load i8, i8* %1017
%1019 = zext i8 %1018 to i32
%1020 = and i32 %1019, 1
%1021 = icmp ne i32 %1020, 0
%1022 = xor i1 %1021, true
%1023 = xor i1 %1022, true
%1024 = zext i1 %1023 to i32
%1025 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.28, i64 0, i64 0), i32 %1005, i32 %1015, i32 %1024)
br label %3259
1026: ; preds = %3
%1027 = load i8*, i8** %5
%1028 = getelementptr inbounds i8, i8* %1027, i64 2
%1029 = load i8, i8* %1028
%1030 = zext i8 %1029 to i32
%1031 = ashr i32 %1030, 2
%1032 = and i32 %1031, 15
%1033 = load i8*, i8** %5
%1034 = getelementptr inbounds i8, i8* %1033, i64 2
%1035 = load i8, i8* %1034
%1036 = zext i8 %1035 to i32
%1037 = and i32 %1036, 2
%1038 = icmp ne i32 %1037, 0
%1039 = xor i1 %1038, true
%1040 = xor i1 %1039, true
%1041 = zext i1 %1040 to i32
%1042 = load i8*, i8** %5
%1043 = getelementptr inbounds i8, i8* %1042, i64 2
%1044 = load i8, i8* %1043
%1045 = zext i8 %1044 to i32
%1046 = and i32 %1045, 1
%1047 = icmp ne i32 %1046, 0
%1048 = xor i1 %1047, true
%1049 = xor i1 %1048, true
%1050 = zext i1 %1049 to i32
%1051 = load i32, i32* %4
%1052 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1032, i32 %1041, i32 %1050, i32 %1051)
%1053 = load i32, i32* %6
%1054 = icmp sgt i32 %1053, 4
br i1 %1054, label %1055, label %1084
1055: ; preds = %1026
%1056 = load i8*, i8** %5
%1057 = getelementptr inbounds i8, i8* %1056, i64 4
%1058 = load i8, i8* %1057
%1059 = zext i8 %1058 to i32
%1060 = and i32 %1059, 4
%1061 = icmp ne i32 %1060, 0
%1062 = xor i1 %1061, true
%1063 = xor i1 %1062, true
%1064 = zext i1 %1063 to i32
%1065 = load i8*, i8** %5
%1066 = getelementptr inbounds i8, i8* %1065, i64 4
%1067 = load i8, i8* %1066
%1068 = zext i8 %1067 to i32
%1069 = and i32 %1068, 2
%1070 = icmp ne i32 %1069, 0
%1071 = xor i1 %1070, true
%1072 = xor i1 %1071, true
%1073 = zext i1 %1072 to i32
%1074 = load i8*, i8** %5
%1075 = getelementptr inbounds i8, i8* %1074, i64 4
%1076 = load i8, i8* %1075
%1077 = zext i8 %1076 to i32
%1078 = and i32 %1077, 1
%1079 = icmp ne i32 %1078, 0
%1080 = xor i1 %1079, true
%1081 = xor i1 %1080, true
%1082 = zext i1 %1081 to i32
%1083 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.38, i64 0, i64 0), i32 %1064, i32 %1073, i32 %1082)
br label %1084
1084: ; preds = %1055, %1026
br label %3259
1085: ; preds = %3
%1086 = load i8*, i8** %5
%1087 = getelementptr inbounds i8, i8* %1086, i64 2
%1088 = load i8, i8* %1087
%1089 = zext i8 %1088 to i32
%1090 = ashr i32 %1089, 2
%1091 = and i32 %1090, 15
%1092 = load i8*, i8** %5
%1093 = getelementptr inbounds i8, i8* %1092, i64 2
%1094 = load i8, i8* %1093
%1095 = zext i8 %1094 to i32
%1096 = and i32 %1095, 2
%1097 = icmp ne i32 %1096, 0
%1098 = xor i1 %1097, true
%1099 = xor i1 %1098, true
%1100 = zext i1 %1099 to i32
%1101 = load i8*, i8** %5
%1102 = getelementptr inbounds i8, i8* %1101, i64 2
%1103 = load i8, i8* %1102
%1104 = zext i8 %1103 to i32
%1105 = and i32 %1104, 1
%1106 = icmp ne i32 %1105, 0
%1107 = xor i1 %1106, true
%1108 = xor i1 %1107, true
%1109 = zext i1 %1108 to i32
%1110 = load i32, i32* %4
%1111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1091, i32 %1100, i32 %1109, i32 %1110)
%1112 = load i32, i32* %6
%1113 = icmp slt i32 %1112, 8
br i1 %1113, label %1114, label %1118
1114: ; preds = %1085
%1115 = load i32, i32* %6
%1116 = sub nsw i32 %1115, 4
%1117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1116)
br label %3259
1118: ; preds = %1085
%1119 = load i8*, i8** %5
%1120 = getelementptr inbounds i8, i8* %1119, i64 4
%1121 = load i8, i8* %1120
%1122 = zext i8 %1121 to i32
%1123 = and i32 %1122, 1
%1124 = icmp ne i32 %1123, 0
%1125 = xor i1 %1124, true
%1126 = xor i1 %1125, true
%1127 = zext i1 %1126 to i32
%1128 = load i8*, i8** %5
%1129 = getelementptr inbounds i8, i8* %1128, i64 5
%1130 = load i8, i8* %1129
%1131 = zext i8 %1130 to i32
%1132 = load i8*, i8** %5
%1133 = getelementptr inbounds i8, i8* %1132, i64 6
%1134 = load i8, i8* %1133
%1135 = zext i8 %1134 to i32
%1136 = shl i32 %1135, 8
%1137 = load i8*, i8** %5
%1138 = getelementptr inbounds i8, i8* %1137, i64 7
%1139 = load i8, i8* %1138
%1140 = zext i8 %1139 to i32
%1141 = add nsw i32 %1136, %1140
%1142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.39, i64 0, i64 0), i32 %1127, i32 %1131, i32 %1141)
br label %3259
1143: ; preds = %3
%1144 = load i8*, i8** %5
%1145 = getelementptr inbounds i8, i8* %1144, i64 2
%1146 = load i8, i8* %1145
%1147 = zext i8 %1146 to i32
%1148 = ashr i32 %1147, 2
%1149 = and i32 %1148, 15
%1150 = load i8*, i8** %5
%1151 = getelementptr inbounds i8, i8* %1150, i64 2
%1152 = load i8, i8* %1151
%1153 = zext i8 %1152 to i32
%1154 = and i32 %1153, 2
%1155 = icmp ne i32 %1154, 0
%1156 = xor i1 %1155, true
%1157 = xor i1 %1156, true
%1158 = zext i1 %1157 to i32
%1159 = load i8*, i8** %5
%1160 = getelementptr inbounds i8, i8* %1159, i64 2
%1161 = load i8, i8* %1160
%1162 = zext i8 %1161 to i32
%1163 = and i32 %1162, 1
%1164 = icmp ne i32 %1163, 0
%1165 = xor i1 %1164, true
%1166 = xor i1 %1165, true
%1167 = zext i1 %1166 to i32
%1168 = load i32, i32* %4
%1169 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1149, i32 %1158, i32 %1167, i32 %1168)
%1170 = load i32, i32* %6
%1171 = icmp slt i32 %1170, 8
br i1 %1171, label %1172, label %1176
1172: ; preds = %1143
%1173 = load i32, i32* %6
%1174 = sub nsw i32 %1173, 4
%1175 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1174)
br label %3259
1176: ; preds = %1143
%1177 = load i8*, i8** %5
%1178 = getelementptr inbounds i8, i8* %1177, i64 4
%1179 = load i8, i8* %1178
%1180 = zext i8 %1179 to i32
%1181 = and i32 %1180, 1
%1182 = icmp ne i32 %1181, 0
%1183 = xor i1 %1182, true
%1184 = xor i1 %1183, true
%1185 = zext i1 %1184 to i32
%1186 = load i8*, i8** %5
%1187 = getelementptr inbounds i8, i8* %1186, i64 5
%1188 = load i8, i8* %1187
%1189 = zext i8 %1188 to i32
%1190 = and i32 %1189, 2
%1191 = icmp ne i32 %1190, 0
%1192 = xor i1 %1191, true
%1193 = xor i1 %1192, true
%1194 = zext i1 %1193 to i32
%1195 = load i8*, i8** %5
%1196 = getelementptr inbounds i8, i8* %1195, i64 5
%1197 = load i8, i8* %1196
%1198 = zext i8 %1197 to i32
%1199 = and i32 %1198, 1
%1200 = icmp ne i32 %1199, 0
%1201 = xor i1 %1200, true
%1202 = xor i1 %1201, true
%1203 = zext i1 %1202 to i32
%1204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.40, i64 0, i64 0), i32 %1185, i32 %1194, i32 %1203)
br label %3259
1205: ; preds = %3
%1206 = load i8*, i8** %5
%1207 = getelementptr inbounds i8, i8* %1206, i64 2
%1208 = load i8, i8* %1207
%1209 = zext i8 %1208 to i32
%1210 = ashr i32 %1209, 2
%1211 = and i32 %1210, 15
%1212 = load i8*, i8** %5
%1213 = getelementptr inbounds i8, i8* %1212, i64 2
%1214 = load i8, i8* %1213
%1215 = zext i8 %1214 to i32
%1216 = and i32 %1215, 2
%1217 = icmp ne i32 %1216, 0
%1218 = xor i1 %1217, true
%1219 = xor i1 %1218, true
%1220 = zext i1 %1219 to i32
%1221 = load i8*, i8** %5
%1222 = getelementptr inbounds i8, i8* %1221, i64 2
%1223 = load i8, i8* %1222
%1224 = zext i8 %1223 to i32
%1225 = and i32 %1224, 1
%1226 = icmp ne i32 %1225, 0
%1227 = xor i1 %1226, true
%1228 = xor i1 %1227, true
%1229 = zext i1 %1228 to i32
%1230 = load i32, i32* %4
%1231 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1211, i32 %1220, i32 %1229, i32 %1230)
%1232 = load i32, i32* %6
%1233 = icmp slt i32 %1232, 8
br i1 %1233, label %1234, label %1238
1234: ; preds = %1205
%1235 = load i32, i32* %6
%1236 = sub nsw i32 %1235, 4
%1237 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1236)
br label %3259
1238: ; preds = %1205
%1239 = load i8*, i8** %5
%1240 = getelementptr inbounds i8, i8* %1239, i64 4
%1241 = load i8, i8* %1240
%1242 = zext i8 %1241 to i32
%1243 = and i32 %1242, 1
%1244 = icmp ne i32 %1243, 0
%1245 = xor i1 %1244, true
%1246 = xor i1 %1245, true
%1247 = zext i1 %1246 to i32
%1248 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.41, i64 0, i64 0), i32 %1247)
br label %3259
1249: ; preds = %3
%1250 = load i8*, i8** %5
%1251 = getelementptr inbounds i8, i8* %1250, i64 2
%1252 = load i8, i8* %1251
%1253 = zext i8 %1252 to i32
%1254 = ashr i32 %1253, 2
%1255 = and i32 %1254, 15
%1256 = load i8*, i8** %5
%1257 = getelementptr inbounds i8, i8* %1256, i64 2
%1258 = load i8, i8* %1257
%1259 = zext i8 %1258 to i32
%1260 = and i32 %1259, 2
%1261 = icmp ne i32 %1260, 0
%1262 = xor i1 %1261, true
%1263 = xor i1 %1262, true
%1264 = zext i1 %1263 to i32
%1265 = load i8*, i8** %5
%1266 = getelementptr inbounds i8, i8* %1265, i64 2
%1267 = load i8, i8* %1266
%1268 = zext i8 %1267 to i32
%1269 = and i32 %1268, 1
%1270 = icmp ne i32 %1269, 0
%1271 = xor i1 %1270, true
%1272 = xor i1 %1271, true
%1273 = zext i1 %1272 to i32
%1274 = load i32, i32* %4
%1275 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1255, i32 %1264, i32 %1273, i32 %1274)
%1276 = load i32, i32* %6
%1277 = icmp slt i32 %1276, 8
br i1 %1277, label %1278, label %1282
1278: ; preds = %1249
%1279 = load i32, i32* %6
%1280 = sub nsw i32 %1279, 4
%1281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1280)
br label %3259
1282: ; preds = %1249
%1283 = load i8*, i8** %5
%1284 = getelementptr inbounds i8, i8* %1283, i64 4
%1285 = load i8, i8* %1284
%1286 = zext i8 %1285 to i32
%1287 = and i32 %1286, 8
%1288 = icmp ne i32 %1287, 0
%1289 = xor i1 %1288, true
%1290 = xor i1 %1289, true
%1291 = zext i1 %1290 to i32
%1292 = load i8*, i8** %5
%1293 = getelementptr inbounds i8, i8* %1292, i64 4
%1294 = load i8, i8* %1293
%1295 = zext i8 %1294 to i32
%1296 = and i32 %1295, 4
%1297 = icmp ne i32 %1296, 0
%1298 = xor i1 %1297, true
%1299 = xor i1 %1298, true
%1300 = zext i1 %1299 to i32
%1301 = load i8*, i8** %5
%1302 = getelementptr inbounds i8, i8* %1301, i64 4
%1303 = load i8, i8* %1302
%1304 = zext i8 %1303 to i32
%1305 = and i32 %1304, 2
%1306 = icmp ne i32 %1305, 0
%1307 = xor i1 %1306, true
%1308 = xor i1 %1307, true
%1309 = zext i1 %1308 to i32
%1310 = load i8*, i8** %5
%1311 = getelementptr inbounds i8, i8* %1310, i64 4
%1312 = load i8, i8* %1311
%1313 = zext i8 %1312 to i32
%1314 = and i32 %1313, 1
%1315 = icmp ne i32 %1314, 0
%1316 = xor i1 %1315, true
%1317 = xor i1 %1316, true
%1318 = zext i1 %1317 to i32
%1319 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.42, i64 0, i64 0), i32 %1291, i32 %1300, i32 %1309, i32 %1318)
br label %3259
1320: ; preds = %3
%1321 = load i8*, i8** %5
%1322 = getelementptr inbounds i8, i8* %1321, i64 2
%1323 = load i8, i8* %1322
%1324 = zext i8 %1323 to i32
%1325 = ashr i32 %1324, 2
%1326 = and i32 %1325, 15
%1327 = load i8*, i8** %5
%1328 = getelementptr inbounds i8, i8* %1327, i64 2
%1329 = load i8, i8* %1328
%1330 = zext i8 %1329 to i32
%1331 = and i32 %1330, 2
%1332 = icmp ne i32 %1331, 0
%1333 = xor i1 %1332, true
%1334 = xor i1 %1333, true
%1335 = zext i1 %1334 to i32
%1336 = load i8*, i8** %5
%1337 = getelementptr inbounds i8, i8* %1336, i64 2
%1338 = load i8, i8* %1337
%1339 = zext i8 %1338 to i32
%1340 = and i32 %1339, 1
%1341 = icmp ne i32 %1340, 0
%1342 = xor i1 %1341, true
%1343 = xor i1 %1342, true
%1344 = zext i1 %1343 to i32
%1345 = load i32, i32* %4
%1346 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1326, i32 %1335, i32 %1344, i32 %1345)
%1347 = load i32, i32* %6
%1348 = icmp slt i32 %1347, 8
br i1 %1348, label %1349, label %1353
1349: ; preds = %1320
%1350 = load i32, i32* %6
%1351 = sub nsw i32 %1350, 4
%1352 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1351)
br label %3259
1353: ; preds = %1320
%1354 = load i8*, i8** %5
%1355 = getelementptr inbounds i8, i8* %1354, i64 4
%1356 = load i8, i8* %1355
%1357 = zext i8 %1356 to i32
%1358 = and i32 %1357, 64
%1359 = icmp ne i32 %1358, 0
%1360 = xor i1 %1359, true
%1361 = xor i1 %1360, true
%1362 = zext i1 %1361 to i32
%1363 = load i8*, i8** %5
%1364 = getelementptr inbounds i8, i8* %1363, i64 4
%1365 = load i8, i8* %1364
%1366 = zext i8 %1365 to i32
%1367 = and i32 %1366, 16
%1368 = icmp ne i32 %1367, 0
%1369 = xor i1 %1368, true
%1370 = xor i1 %1369, true
%1371 = zext i1 %1370 to i32
%1372 = load i8*, i8** %5
%1373 = getelementptr inbounds i8, i8* %1372, i64 4
%1374 = load i8, i8* %1373
%1375 = zext i8 %1374 to i32
%1376 = and i32 %1375, 8
%1377 = icmp ne i32 %1376, 0
%1378 = xor i1 %1377, true
%1379 = xor i1 %1378, true
%1380 = zext i1 %1379 to i32
%1381 = load i8*, i8** %5
%1382 = getelementptr inbounds i8, i8* %1381, i64 4
%1383 = load i8, i8* %1382
%1384 = zext i8 %1383 to i32
%1385 = and i32 %1384, 4
%1386 = icmp ne i32 %1385, 0
%1387 = xor i1 %1386, true
%1388 = xor i1 %1387, true
%1389 = zext i1 %1388 to i32
%1390 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.43, i64 0, i64 0), i32 %1362, i32 %1371, i32 %1380, i32 %1389)
%1391 = load i8*, i8** %5
%1392 = getelementptr inbounds i8, i8* %1391, i64 4
%1393 = load i8, i8* %1392
%1394 = zext i8 %1393 to i32
%1395 = and i32 %1394, 2
%1396 = icmp ne i32 %1395, 0
%1397 = xor i1 %1396, true
%1398 = xor i1 %1397, true
%1399 = zext i1 %1398 to i32
%1400 = load i8*, i8** %5
%1401 = getelementptr inbounds i8, i8* %1400, i64 4
%1402 = load i8, i8* %1401
%1403 = zext i8 %1402 to i32
%1404 = and i32 %1403, 1
%1405 = icmp ne i32 %1404, 0
%1406 = xor i1 %1405, true
%1407 = xor i1 %1406, true
%1408 = zext i1 %1407 to i32
%1409 = load i8*, i8** %5
%1410 = getelementptr inbounds i8, i8* %1409, i64 6
%1411 = load i8, i8* %1410
%1412 = zext i8 %1411 to i32
%1413 = shl i32 %1412, 8
%1414 = load i8*, i8** %5
%1415 = getelementptr inbounds i8, i8* %1414, i64 7
%1416 = load i8, i8* %1415
%1417 = zext i8 %1416 to i32
%1418 = add nsw i32 %1413, %1417
%1419 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.44, i64 0, i64 0), i32 %1399, i32 %1408, i32 %1418)
br label %3259
1420: ; preds = %3
%1421 = load i8*, i8** %5
%1422 = getelementptr inbounds i8, i8* %1421, i64 2
%1423 = load i8, i8* %1422
%1424 = zext i8 %1423 to i32
%1425 = ashr i32 %1424, 2
%1426 = and i32 %1425, 15
%1427 = load i8*, i8** %5
%1428 = getelementptr inbounds i8, i8* %1427, i64 2
%1429 = load i8, i8* %1428
%1430 = zext i8 %1429 to i32
%1431 = and i32 %1430, 2
%1432 = icmp ne i32 %1431, 0
%1433 = xor i1 %1432, true
%1434 = xor i1 %1433, true
%1435 = zext i1 %1434 to i32
%1436 = load i8*, i8** %5
%1437 = getelementptr inbounds i8, i8* %1436, i64 2
%1438 = load i8, i8* %1437
%1439 = zext i8 %1438 to i32
%1440 = and i32 %1439, 1
%1441 = icmp ne i32 %1440, 0
%1442 = xor i1 %1441, true
%1443 = xor i1 %1442, true
%1444 = zext i1 %1443 to i32
%1445 = load i32, i32* %4
%1446 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1426, i32 %1435, i32 %1444, i32 %1445)
%1447 = load i32, i32* %6
%1448 = icmp slt i32 %1447, 8
br i1 %1448, label %1449, label %1453
1449: ; preds = %1420
%1450 = load i32, i32* %6
%1451 = sub nsw i32 %1450, 4
%1452 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1451)
br label %3259
1453: ; preds = %1420
%1454 = load i8*, i8** %5
%1455 = getelementptr inbounds i8, i8* %1454, i64 4
%1456 = load i8, i8* %1455
%1457 = zext i8 %1456 to i32
%1458 = and i32 %1457, 64
%1459 = icmp ne i32 %1458, 0
%1460 = xor i1 %1459, true
%1461 = xor i1 %1460, true
%1462 = zext i1 %1461 to i32
%1463 = load i8*, i8** %5
%1464 = getelementptr inbounds i8, i8* %1463, i64 4
%1465 = load i8, i8* %1464
%1466 = zext i8 %1465 to i32
%1467 = and i32 %1466, 32
%1468 = icmp ne i32 %1467, 0
%1469 = xor i1 %1468, true
%1470 = xor i1 %1469, true
%1471 = zext i1 %1470 to i32
%1472 = load i8*, i8** %5
%1473 = getelementptr inbounds i8, i8* %1472, i64 4
%1474 = load i8, i8* %1473
%1475 = zext i8 %1474 to i32
%1476 = and i32 %1475, 16
%1477 = icmp ne i32 %1476, 0
%1478 = xor i1 %1477, true
%1479 = xor i1 %1478, true
%1480 = zext i1 %1479 to i32
%1481 = load i8*, i8** %5
%1482 = getelementptr inbounds i8, i8* %1481, i64 4
%1483 = load i8, i8* %1482
%1484 = zext i8 %1483 to i32
%1485 = and i32 %1484, 8
%1486 = icmp ne i32 %1485, 0
%1487 = xor i1 %1486, true
%1488 = xor i1 %1487, true
%1489 = zext i1 %1488 to i32
%1490 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.45, i64 0, i64 0), i32 %1462, i32 %1471, i32 %1480, i32 %1489)
%1491 = load i8*, i8** %5
%1492 = getelementptr inbounds i8, i8* %1491, i64 4
%1493 = load i8, i8* %1492
%1494 = zext i8 %1493 to i32
%1495 = and i32 %1494, 4
%1496 = icmp ne i32 %1495, 0
%1497 = xor i1 %1496, true
%1498 = xor i1 %1497, true
%1499 = zext i1 %1498 to i32
%1500 = load i8*, i8** %5
%1501 = getelementptr inbounds i8, i8* %1500, i64 4
%1502 = load i8, i8* %1501
%1503 = zext i8 %1502 to i32
%1504 = and i32 %1503, 2
%1505 = icmp ne i32 %1504, 0
%1506 = xor i1 %1505, true
%1507 = xor i1 %1506, true
%1508 = zext i1 %1507 to i32
%1509 = load i8*, i8** %5
%1510 = getelementptr inbounds i8, i8* %1509, i64 4
%1511 = load i8, i8* %1510
%1512 = zext i8 %1511 to i32
%1513 = and i32 %1512, 1
%1514 = icmp ne i32 %1513, 0
%1515 = xor i1 %1514, true
%1516 = xor i1 %1515, true
%1517 = zext i1 %1516 to i32
%1518 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.46, i64 0, i64 0), i32 %1499, i32 %1508, i32 %1517)
%1519 = load i8*, i8** %5
%1520 = getelementptr inbounds i8, i8* %1519, i64 5
%1521 = load i8, i8* %1520
%1522 = zext i8 %1521 to i32
%1523 = shl i32 %1522, 16
%1524 = load i8*, i8** %5
%1525 = getelementptr inbounds i8, i8* %1524, i64 6
%1526 = load i8, i8* %1525
%1527 = zext i8 %1526 to i32
%1528 = shl i32 %1527, 8
%1529 = add nsw i32 %1523, %1528
%1530 = load i8*, i8** %5
%1531 = getelementptr inbounds i8, i8* %1530, i64 7
%1532 = load i8, i8* %1531
%1533 = zext i8 %1532 to i32
%1534 = add nsw i32 %1529, %1533
%1535 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.47, i64 0, i64 0), i32 %1534)
br label %3259
1536: ; preds = %3
%1537 = load i8*, i8** %5
%1538 = getelementptr inbounds i8, i8* %1537, i64 2
%1539 = load i8, i8* %1538
%1540 = zext i8 %1539 to i32
%1541 = ashr i32 %1540, 2
%1542 = and i32 %1541, 15
%1543 = load i8*, i8** %5
%1544 = getelementptr inbounds i8, i8* %1543, i64 2
%1545 = load i8, i8* %1544
%1546 = zext i8 %1545 to i32
%1547 = and i32 %1546, 2
%1548 = icmp ne i32 %1547, 0
%1549 = xor i1 %1548, true
%1550 = xor i1 %1549, true
%1551 = zext i1 %1550 to i32
%1552 = load i8*, i8** %5
%1553 = getelementptr inbounds i8, i8* %1552, i64 2
%1554 = load i8, i8* %1553
%1555 = zext i8 %1554 to i32
%1556 = and i32 %1555, 1
%1557 = icmp ne i32 %1556, 0
%1558 = xor i1 %1557, true
%1559 = xor i1 %1558, true
%1560 = zext i1 %1559 to i32
%1561 = load i32, i32* %4
%1562 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1542, i32 %1551, i32 %1560, i32 %1561)
%1563 = load i32, i32* %6
%1564 = icmp slt i32 %1563, 8
br i1 %1564, label %1565, label %1569
1565: ; preds = %1536
%1566 = load i32, i32* %6
%1567 = sub nsw i32 %1566, 4
%1568 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1567)
br label %3259
1569: ; preds = %1536
%1570 = load i8*, i8** %5
%1571 = getelementptr inbounds i8, i8* %1570, i64 4
%1572 = load i8, i8* %1571
%1573 = zext i8 %1572 to i32
%1574 = and i32 %1573, 64
%1575 = icmp ne i32 %1574, 0
%1576 = xor i1 %1575, true
%1577 = xor i1 %1576, true
%1578 = zext i1 %1577 to i32
%1579 = load i8*, i8** %5
%1580 = getelementptr inbounds i8, i8* %1579, i64 4
%1581 = load i8, i8* %1580
%1582 = zext i8 %1581 to i32
%1583 = and i32 %1582, 8
%1584 = icmp ne i32 %1583, 0
%1585 = xor i1 %1584, true
%1586 = xor i1 %1585, true
%1587 = zext i1 %1586 to i32
%1588 = load i8*, i8** %5
%1589 = getelementptr inbounds i8, i8* %1588, i64 4
%1590 = load i8, i8* %1589
%1591 = zext i8 %1590 to i32
%1592 = and i32 %1591, 4
%1593 = icmp ne i32 %1592, 0
%1594 = xor i1 %1593, true
%1595 = xor i1 %1594, true
%1596 = zext i1 %1595 to i32
%1597 = load i8*, i8** %5
%1598 = getelementptr inbounds i8, i8* %1597, i64 4
%1599 = load i8, i8* %1598
%1600 = zext i8 %1599 to i32
%1601 = and i32 %1600, 2
%1602 = icmp ne i32 %1601, 0
%1603 = xor i1 %1602, true
%1604 = xor i1 %1603, true
%1605 = zext i1 %1604 to i32
%1606 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.48, i64 0, i64 0), i32 %1578, i32 %1587, i32 %1596, i32 %1605)
br label %3259
1607: ; preds = %3
%1608 = load i8*, i8** %5
%1609 = getelementptr inbounds i8, i8* %1608, i64 2
%1610 = load i8, i8* %1609
%1611 = zext i8 %1610 to i32
%1612 = ashr i32 %1611, 2
%1613 = and i32 %1612, 15
%1614 = load i8*, i8** %5
%1615 = getelementptr inbounds i8, i8* %1614, i64 2
%1616 = load i8, i8* %1615
%1617 = zext i8 %1616 to i32
%1618 = and i32 %1617, 2
%1619 = icmp ne i32 %1618, 0
%1620 = xor i1 %1619, true
%1621 = xor i1 %1620, true
%1622 = zext i1 %1621 to i32
%1623 = load i8*, i8** %5
%1624 = getelementptr inbounds i8, i8* %1623, i64 2
%1625 = load i8, i8* %1624
%1626 = zext i8 %1625 to i32
%1627 = and i32 %1626, 1
%1628 = icmp ne i32 %1627, 0
%1629 = xor i1 %1628, true
%1630 = xor i1 %1629, true
%1631 = zext i1 %1630 to i32
%1632 = load i32, i32* %4
%1633 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1613, i32 %1622, i32 %1631, i32 %1632)
%1634 = load i32, i32* %6
%1635 = icmp slt i32 %1634, 8
br i1 %1635, label %1636, label %1640
1636: ; preds = %1607
%1637 = load i32, i32* %6
%1638 = sub nsw i32 %1637, 4
%1639 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1638)
br label %3259
1640: ; preds = %1607
%1641 = load i8*, i8** %5
%1642 = getelementptr inbounds i8, i8* %1641, i64 7
%1643 = load i8, i8* %1642
%1644 = zext i8 %1643 to i32
store i32 %1644, i32* %8
%1645 = load i32, i32* %8
%1646 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.33, i64 0, i64 0), i32 %1645)
store i32 0, i32* %7
br label %1647
1647: ; preds = %1660, %1640
%1648 = load i32, i32* %7
%1649 = load i32, i32* %8
%1650 = icmp slt i32 %1648, %1649
br i1 %1650, label %1651, label %1663
1651: ; preds = %1647
%1652 = load i8*, i8** %5
%1653 = load i32, i32* %7
%1654 = add nsw i32 8, %1653
%1655 = sext i32 %1654 to i64
%1656 = getelementptr inbounds i8, i8* %1652, i64 %1655
%1657 = load i8, i8* %1656
%1658 = zext i8 %1657 to i32
%1659 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.34, i64 0, i64 0), i32 %1658)
br label %1660
1660: ; preds = %1651
%1661 = load i32, i32* %7
%1662 = add nsw i32 %1661, 1
store i32 %1662, i32* %7
br label %1647
1663: ; preds = %1647
br label %3259
1664: ; preds = %3
%1665 = load i8*, i8** %5
%1666 = getelementptr inbounds i8, i8* %1665, i64 2
%1667 = load i8, i8* %1666
%1668 = zext i8 %1667 to i32
%1669 = ashr i32 %1668, 2
%1670 = and i32 %1669, 15
%1671 = load i8*, i8** %5
%1672 = getelementptr inbounds i8, i8* %1671, i64 2
%1673 = load i8, i8* %1672
%1674 = zext i8 %1673 to i32
%1675 = and i32 %1674, 2
%1676 = icmp ne i32 %1675, 0
%1677 = xor i1 %1676, true
%1678 = xor i1 %1677, true
%1679 = zext i1 %1678 to i32
%1680 = load i8*, i8** %5
%1681 = getelementptr inbounds i8, i8* %1680, i64 2
%1682 = load i8, i8* %1681
%1683 = zext i8 %1682 to i32
%1684 = and i32 %1683, 1
%1685 = icmp ne i32 %1684, 0
%1686 = xor i1 %1685, true
%1687 = xor i1 %1686, true
%1688 = zext i1 %1687 to i32
%1689 = load i32, i32* %4
%1690 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1670, i32 %1679, i32 %1688, i32 %1689)
%1691 = load i32, i32* %6
%1692 = icmp slt i32 %1691, 8
br i1 %1692, label %1693, label %1697
1693: ; preds = %1664
%1694 = load i32, i32* %6
%1695 = sub nsw i32 %1694, 4
%1696 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1695)
br label %3259
1697: ; preds = %1664
%1698 = load i8*, i8** %5
%1699 = getelementptr inbounds i8, i8* %1698, i64 4
%1700 = load i8, i8* %1699
%1701 = zext i8 %1700 to i32
%1702 = and i32 %1701, 1
%1703 = icmp ne i32 %1702, 0
%1704 = xor i1 %1703, true
%1705 = xor i1 %1704, true
%1706 = zext i1 %1705 to i32
%1707 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.49, i64 0, i64 0), i32 %1706)
%1708 = load i8*, i8** %5
%1709 = getelementptr inbounds i8, i8* %1708, i64 7
%1710 = load i8, i8* %1709
%1711 = zext i8 %1710 to i32
%1712 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.50, i64 0, i64 0), i32 %1711)
br label %3259
1713: ; preds = %3
%1714 = load i8*, i8** %5
%1715 = getelementptr inbounds i8, i8* %1714, i64 2
%1716 = load i8, i8* %1715
%1717 = zext i8 %1716 to i32
%1718 = ashr i32 %1717, 2
%1719 = and i32 %1718, 15
%1720 = load i8*, i8** %5
%1721 = getelementptr inbounds i8, i8* %1720, i64 2
%1722 = load i8, i8* %1721
%1723 = zext i8 %1722 to i32
%1724 = and i32 %1723, 2
%1725 = icmp ne i32 %1724, 0
%1726 = xor i1 %1725, true
%1727 = xor i1 %1726, true
%1728 = zext i1 %1727 to i32
%1729 = load i8*, i8** %5
%1730 = getelementptr inbounds i8, i8* %1729, i64 2
%1731 = load i8, i8* %1730
%1732 = zext i8 %1731 to i32
%1733 = and i32 %1732, 1
%1734 = icmp ne i32 %1733, 0
%1735 = xor i1 %1734, true
%1736 = xor i1 %1735, true
%1737 = zext i1 %1736 to i32
%1738 = load i32, i32* %4
%1739 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1719, i32 %1728, i32 %1737, i32 %1738)
%1740 = load i32, i32* %6
%1741 = icmp slt i32 %1740, 8
br i1 %1741, label %1742, label %1746
1742: ; preds = %1713
%1743 = load i32, i32* %6
%1744 = sub nsw i32 %1743, 4
%1745 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1744)
br label %3259
1746: ; preds = %1713
%1747 = load i8*, i8** %5
%1748 = getelementptr inbounds i8, i8* %1747, i64 5
%1749 = load i8, i8* %1748
%1750 = zext i8 %1749 to i32
%1751 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.51, i64 0, i64 0), i32 %1750)
br label %3259
1752: ; preds = %3
%1753 = load i8*, i8** %5
%1754 = getelementptr inbounds i8, i8* %1753, i64 2
%1755 = load i8, i8* %1754
%1756 = zext i8 %1755 to i32
%1757 = ashr i32 %1756, 2
%1758 = and i32 %1757, 15
%1759 = load i8*, i8** %5
%1760 = getelementptr inbounds i8, i8* %1759, i64 2
%1761 = load i8, i8* %1760
%1762 = zext i8 %1761 to i32
%1763 = and i32 %1762, 2
%1764 = icmp ne i32 %1763, 0
%1765 = xor i1 %1764, true
%1766 = xor i1 %1765, true
%1767 = zext i1 %1766 to i32
%1768 = load i8*, i8** %5
%1769 = getelementptr inbounds i8, i8* %1768, i64 2
%1770 = load i8, i8* %1769
%1771 = zext i8 %1770 to i32
%1772 = and i32 %1771, 1
%1773 = icmp ne i32 %1772, 0
%1774 = xor i1 %1773, true
%1775 = xor i1 %1774, true
%1776 = zext i1 %1775 to i32
%1777 = load i32, i32* %4
%1778 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1758, i32 %1767, i32 %1776, i32 %1777)
%1779 = load i32, i32* %6
%1780 = icmp slt i32 %1779, 8
br i1 %1780, label %1781, label %1785
1781: ; preds = %1752
%1782 = load i32, i32* %6
%1783 = sub nsw i32 %1782, 4
%1784 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1783)
br label %3259
1785: ; preds = %1752
%1786 = load i8*, i8** %5
%1787 = getelementptr inbounds i8, i8* %1786, i64 4
%1788 = load i8, i8* %1787
%1789 = zext i8 %1788 to i32
%1790 = and i32 %1789, 1
%1791 = icmp ne i32 %1790, 0
%1792 = xor i1 %1791, true
%1793 = xor i1 %1792, true
%1794 = zext i1 %1793 to i32
%1795 = load i8*, i8** %5
%1796 = getelementptr inbounds i8, i8* %1795, i64 5
%1797 = load i8, i8* %1796
%1798 = zext i8 %1797 to i32
%1799 = and i32 %1798, 2
%1800 = icmp ne i32 %1799, 0
%1801 = xor i1 %1800, true
%1802 = xor i1 %1801, true
%1803 = zext i1 %1802 to i32
%1804 = load i8*, i8** %5
%1805 = getelementptr inbounds i8, i8* %1804, i64 5
%1806 = load i8, i8* %1805
%1807 = zext i8 %1806 to i32
%1808 = and i32 %1807, 1
%1809 = icmp ne i32 %1808, 0
%1810 = xor i1 %1809, true
%1811 = xor i1 %1810, true
%1812 = zext i1 %1811 to i32
%1813 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.52, i64 0, i64 0), i32 %1794, i32 %1803, i32 %1812)
br label %3259
1814: ; preds = %3
%1815 = load i8*, i8** %5
%1816 = getelementptr inbounds i8, i8* %1815, i64 2
%1817 = load i8, i8* %1816
%1818 = zext i8 %1817 to i32
%1819 = ashr i32 %1818, 2
%1820 = and i32 %1819, 15
%1821 = load i8*, i8** %5
%1822 = getelementptr inbounds i8, i8* %1821, i64 2
%1823 = load i8, i8* %1822
%1824 = zext i8 %1823 to i32
%1825 = and i32 %1824, 2
%1826 = icmp ne i32 %1825, 0
%1827 = xor i1 %1826, true
%1828 = xor i1 %1827, true
%1829 = zext i1 %1828 to i32
%1830 = load i8*, i8** %5
%1831 = getelementptr inbounds i8, i8* %1830, i64 2
%1832 = load i8, i8* %1831
%1833 = zext i8 %1832 to i32
%1834 = and i32 %1833, 1
%1835 = icmp ne i32 %1834, 0
%1836 = xor i1 %1835, true
%1837 = xor i1 %1836, true
%1838 = zext i1 %1837 to i32
%1839 = load i32, i32* %4
%1840 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1820, i32 %1829, i32 %1838, i32 %1839)
%1841 = load i32, i32* %6
%1842 = icmp slt i32 %1841, 8
br i1 %1842, label %1843, label %1847
1843: ; preds = %1814
%1844 = load i32, i32* %6
%1845 = sub nsw i32 %1844, 4
%1846 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1845)
br label %3259
1847: ; preds = %1814
%1848 = load i8*, i8** %5
%1849 = getelementptr inbounds i8, i8* %1848, i64 4
%1850 = load i8, i8* %1849
%1851 = zext i8 %1850 to i32
%1852 = and i32 %1851, 1
%1853 = icmp ne i32 %1852, 0
%1854 = xor i1 %1853, true
%1855 = xor i1 %1854, true
%1856 = zext i1 %1855 to i32
%1857 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.53, i64 0, i64 0), i32 %1856)
br label %3259
1858: ; preds = %3
%1859 = load i8*, i8** %5
%1860 = getelementptr inbounds i8, i8* %1859, i64 2
%1861 = load i8, i8* %1860
%1862 = zext i8 %1861 to i32
%1863 = ashr i32 %1862, 2
%1864 = and i32 %1863, 15
%1865 = load i8*, i8** %5
%1866 = getelementptr inbounds i8, i8* %1865, i64 2
%1867 = load i8, i8* %1866
%1868 = zext i8 %1867 to i32
%1869 = and i32 %1868, 2
%1870 = icmp ne i32 %1869, 0
%1871 = xor i1 %1870, true
%1872 = xor i1 %1871, true
%1873 = zext i1 %1872 to i32
%1874 = load i8*, i8** %5
%1875 = getelementptr inbounds i8, i8* %1874, i64 2
%1876 = load i8, i8* %1875
%1877 = zext i8 %1876 to i32
%1878 = and i32 %1877, 1
%1879 = icmp ne i32 %1878, 0
%1880 = xor i1 %1879, true
%1881 = xor i1 %1880, true
%1882 = zext i1 %1881 to i32
%1883 = load i32, i32* %4
%1884 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1864, i32 %1873, i32 %1882, i32 %1883)
%1885 = load i32, i32* %6
%1886 = icmp slt i32 %1885, 32
br i1 %1886, label %1887, label %1891
1887: ; preds = %1858
%1888 = load i32, i32* %6
%1889 = sub nsw i32 %1888, 4
%1890 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1889)
br label %3259
1891: ; preds = %1858
%1892 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.54, i64 0, i64 0))
%1893 = load i8*, i8** %5
%1894 = getelementptr inbounds i8, i8* %1893, i64 8
%1895 = load i8, i8* %1894
%1896 = zext i8 %1895 to i32
%1897 = shl i32 %1896, 8
%1898 = load i8*, i8** %5
%1899 = getelementptr inbounds i8, i8* %1898, i64 9
%1900 = load i8, i8* %1899
%1901 = zext i8 %1900 to i32
%1902 = add nsw i32 %1897, %1901
%1903 = load i8*, i8** %5
%1904 = getelementptr inbounds i8, i8* %1903, i64 10
%1905 = load i8, i8* %1904
%1906 = zext i8 %1905 to i32
%1907 = shl i32 %1906, 8
%1908 = load i8*, i8** %5
%1909 = getelementptr inbounds i8, i8* %1908, i64 11
%1910 = load i8, i8* %1909
%1911 = zext i8 %1910 to i32
%1912 = add nsw i32 %1907, %1911
%1913 = load i8*, i8** %5
%1914 = getelementptr inbounds i8, i8* %1913, i64 12
%1915 = load i8, i8* %1914
%1916 = zext i8 %1915 to i32
%1917 = shl i32 %1916, 8
%1918 = load i8*, i8** %5
%1919 = getelementptr inbounds i8, i8* %1918, i64 13
%1920 = load i8, i8* %1919
%1921 = zext i8 %1920 to i32
%1922 = add nsw i32 %1917, %1921
%1923 = load i8*, i8** %5
%1924 = getelementptr inbounds i8, i8* %1923, i64 14
%1925 = load i8, i8* %1924
%1926 = zext i8 %1925 to i32
%1927 = shl i32 %1926, 8
%1928 = load i8*, i8** %5
%1929 = getelementptr inbounds i8, i8* %1928, i64 15
%1930 = load i8, i8* %1929
%1931 = zext i8 %1930 to i32
%1932 = add nsw i32 %1927, %1931
%1933 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %1902, i32 %1912, i32 %1922, i32 %1932)
%1934 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.56, i64 0, i64 0))
%1935 = load i8*, i8** %5
%1936 = getelementptr inbounds i8, i8* %1935, i64 16
%1937 = load i8, i8* %1936
%1938 = zext i8 %1937 to i32
%1939 = shl i32 %1938, 8
%1940 = load i8*, i8** %5
%1941 = getelementptr inbounds i8, i8* %1940, i64 17
%1942 = load i8, i8* %1941
%1943 = zext i8 %1942 to i32
%1944 = add nsw i32 %1939, %1943
%1945 = load i8*, i8** %5
%1946 = getelementptr inbounds i8, i8* %1945, i64 18
%1947 = load i8, i8* %1946
%1948 = zext i8 %1947 to i32
%1949 = shl i32 %1948, 8
%1950 = load i8*, i8** %5
%1951 = getelementptr inbounds i8, i8* %1950, i64 19
%1952 = load i8, i8* %1951
%1953 = zext i8 %1952 to i32
%1954 = add nsw i32 %1949, %1953
%1955 = load i8*, i8** %5
%1956 = getelementptr inbounds i8, i8* %1955, i64 20
%1957 = load i8, i8* %1956
%1958 = zext i8 %1957 to i32
%1959 = shl i32 %1958, 8
%1960 = load i8*, i8** %5
%1961 = getelementptr inbounds i8, i8* %1960, i64 21
%1962 = load i8, i8* %1961
%1963 = zext i8 %1962 to i32
%1964 = add nsw i32 %1959, %1963
%1965 = load i8*, i8** %5
%1966 = getelementptr inbounds i8, i8* %1965, i64 22
%1967 = load i8, i8* %1966
%1968 = zext i8 %1967 to i32
%1969 = shl i32 %1968, 8
%1970 = load i8*, i8** %5
%1971 = getelementptr inbounds i8, i8* %1970, i64 23
%1972 = load i8, i8* %1971
%1973 = zext i8 %1972 to i32
%1974 = add nsw i32 %1969, %1973
%1975 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %1944, i32 %1954, i32 %1964, i32 %1974)
%1976 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.57, i64 0, i64 0))
%1977 = load i8*, i8** %5
%1978 = getelementptr inbounds i8, i8* %1977, i64 24
%1979 = load i8, i8* %1978
%1980 = zext i8 %1979 to i32
%1981 = shl i32 %1980, 8
%1982 = load i8*, i8** %5
%1983 = getelementptr inbounds i8, i8* %1982, i64 25
%1984 = load i8, i8* %1983
%1985 = zext i8 %1984 to i32
%1986 = add nsw i32 %1981, %1985
%1987 = load i8*, i8** %5
%1988 = getelementptr inbounds i8, i8* %1987, i64 26
%1989 = load i8, i8* %1988
%1990 = zext i8 %1989 to i32
%1991 = shl i32 %1990, 8
%1992 = load i8*, i8** %5
%1993 = getelementptr inbounds i8, i8* %1992, i64 27
%1994 = load i8, i8* %1993
%1995 = zext i8 %1994 to i32
%1996 = add nsw i32 %1991, %1995
%1997 = load i8*, i8** %5
%1998 = getelementptr inbounds i8, i8* %1997, i64 28
%1999 = load i8, i8* %1998
%2000 = zext i8 %1999 to i32
%2001 = shl i32 %2000, 8
%2002 = load i8*, i8** %5
%2003 = getelementptr inbounds i8, i8* %2002, i64 29
%2004 = load i8, i8* %2003
%2005 = zext i8 %2004 to i32
%2006 = add nsw i32 %2001, %2005
%2007 = load i8*, i8** %5
%2008 = getelementptr inbounds i8, i8* %2007, i64 30
%2009 = load i8, i8* %2008
%2010 = zext i8 %2009 to i32
%2011 = shl i32 %2010, 8
%2012 = load i8*, i8** %5
%2013 = getelementptr inbounds i8, i8* %2012, i64 31
%2014 = load i8, i8* %2013
%2015 = zext i8 %2014 to i32
%2016 = add nsw i32 %2011, %2015
%2017 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %1986, i32 %1996, i32 %2006, i32 %2016)
br label %3259
2018: ; preds = %3
%2019 = load i8*, i8** %5
%2020 = getelementptr inbounds i8, i8* %2019, i64 2
%2021 = load i8, i8* %2020
%2022 = zext i8 %2021 to i32
%2023 = ashr i32 %2022, 2
%2024 = and i32 %2023, 15
%2025 = load i8*, i8** %5
%2026 = getelementptr inbounds i8, i8* %2025, i64 2
%2027 = load i8, i8* %2026
%2028 = zext i8 %2027 to i32
%2029 = and i32 %2028, 2
%2030 = icmp ne i32 %2029, 0
%2031 = xor i1 %2030, true
%2032 = xor i1 %2031, true
%2033 = zext i1 %2032 to i32
%2034 = load i8*, i8** %5
%2035 = getelementptr inbounds i8, i8* %2034, i64 2
%2036 = load i8, i8* %2035
%2037 = zext i8 %2036 to i32
%2038 = and i32 %2037, 1
%2039 = icmp ne i32 %2038, 0
%2040 = xor i1 %2039, true
%2041 = xor i1 %2040, true
%2042 = zext i1 %2041 to i32
%2043 = load i32, i32* %4
%2044 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2024, i32 %2033, i32 %2042, i32 %2043)
%2045 = load i32, i32* %6
%2046 = icmp slt i32 %2045, 32
br i1 %2046, label %2047, label %2051
2047: ; preds = %2018
%2048 = load i32, i32* %6
%2049 = sub nsw i32 %2048, 4
%2050 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2049)
br label %3259
2051: ; preds = %2018
%2052 = load i8*, i8** %5
%2053 = getelementptr inbounds i8, i8* %2052, i64 4
%2054 = load i8, i8* %2053
%2055 = zext i8 %2054 to i32
%2056 = and i32 %2055, 1
%2057 = icmp ne i32 %2056, 0
%2058 = xor i1 %2057, true
%2059 = xor i1 %2058, true
%2060 = zext i1 %2059 to i32
%2061 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.58, i64 0, i64 0), i32 %2060)
%2062 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.59, i64 0, i64 0))
%2063 = load i8*, i8** %5
%2064 = getelementptr inbounds i8, i8* %2063, i64 8
%2065 = load i8, i8* %2064
%2066 = zext i8 %2065 to i32
%2067 = shl i32 %2066, 8
%2068 = load i8*, i8** %5
%2069 = getelementptr inbounds i8, i8* %2068, i64 9
%2070 = load i8, i8* %2069
%2071 = zext i8 %2070 to i32
%2072 = add nsw i32 %2067, %2071
%2073 = load i8*, i8** %5
%2074 = getelementptr inbounds i8, i8* %2073, i64 10
%2075 = load i8, i8* %2074
%2076 = zext i8 %2075 to i32
%2077 = shl i32 %2076, 8
%2078 = load i8*, i8** %5
%2079 = getelementptr inbounds i8, i8* %2078, i64 11
%2080 = load i8, i8* %2079
%2081 = zext i8 %2080 to i32
%2082 = add nsw i32 %2077, %2081
%2083 = load i8*, i8** %5
%2084 = getelementptr inbounds i8, i8* %2083, i64 12
%2085 = load i8, i8* %2084
%2086 = zext i8 %2085 to i32
%2087 = shl i32 %2086, 8
%2088 = load i8*, i8** %5
%2089 = getelementptr inbounds i8, i8* %2088, i64 13
%2090 = load i8, i8* %2089
%2091 = zext i8 %2090 to i32
%2092 = add nsw i32 %2087, %2091
%2093 = load i8*, i8** %5
%2094 = getelementptr inbounds i8, i8* %2093, i64 14
%2095 = load i8, i8* %2094
%2096 = zext i8 %2095 to i32
%2097 = shl i32 %2096, 8
%2098 = load i8*, i8** %5
%2099 = getelementptr inbounds i8, i8* %2098, i64 15
%2100 = load i8, i8* %2099
%2101 = zext i8 %2100 to i32
%2102 = add nsw i32 %2097, %2101
%2103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %2072, i32 %2082, i32 %2092, i32 %2102)
%2104 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.60, i64 0, i64 0))
%2105 = load i8*, i8** %5
%2106 = getelementptr inbounds i8, i8* %2105, i64 16
%2107 = load i8, i8* %2106
%2108 = zext i8 %2107 to i32
%2109 = shl i32 %2108, 8
%2110 = load i8*, i8** %5
%2111 = getelementptr inbounds i8, i8* %2110, i64 17
%2112 = load i8, i8* %2111
%2113 = zext i8 %2112 to i32
%2114 = add nsw i32 %2109, %2113
%2115 = load i8*, i8** %5
%2116 = getelementptr inbounds i8, i8* %2115, i64 18
%2117 = load i8, i8* %2116
%2118 = zext i8 %2117 to i32
%2119 = shl i32 %2118, 8
%2120 = load i8*, i8** %5
%2121 = getelementptr inbounds i8, i8* %2120, i64 19
%2122 = load i8, i8* %2121
%2123 = zext i8 %2122 to i32
%2124 = add nsw i32 %2119, %2123
%2125 = load i8*, i8** %5
%2126 = getelementptr inbounds i8, i8* %2125, i64 20
%2127 = load i8, i8* %2126
%2128 = zext i8 %2127 to i32
%2129 = shl i32 %2128, 8
%2130 = load i8*, i8** %5
%2131 = getelementptr inbounds i8, i8* %2130, i64 21
%2132 = load i8, i8* %2131
%2133 = zext i8 %2132 to i32
%2134 = add nsw i32 %2129, %2133
%2135 = load i8*, i8** %5
%2136 = getelementptr inbounds i8, i8* %2135, i64 22
%2137 = load i8, i8* %2136
%2138 = zext i8 %2137 to i32
%2139 = shl i32 %2138, 8
%2140 = load i8*, i8** %5
%2141 = getelementptr inbounds i8, i8* %2140, i64 23
%2142 = load i8, i8* %2141
%2143 = zext i8 %2142 to i32
%2144 = add nsw i32 %2139, %2143
%2145 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %2114, i32 %2124, i32 %2134, i32 %2144)
%2146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.61, i64 0, i64 0))
%2147 = load i8*, i8** %5
%2148 = getelementptr inbounds i8, i8* %2147, i64 24
%2149 = load i8, i8* %2148
%2150 = zext i8 %2149 to i32
%2151 = shl i32 %2150, 8
%2152 = load i8*, i8** %5
%2153 = getelementptr inbounds i8, i8* %2152, i64 25
%2154 = load i8, i8* %2153
%2155 = zext i8 %2154 to i32
%2156 = add nsw i32 %2151, %2155
%2157 = load i8*, i8** %5
%2158 = getelementptr inbounds i8, i8* %2157, i64 26
%2159 = load i8, i8* %2158
%2160 = zext i8 %2159 to i32
%2161 = shl i32 %2160, 8
%2162 = load i8*, i8** %5
%2163 = getelementptr inbounds i8, i8* %2162, i64 27
%2164 = load i8, i8* %2163
%2165 = zext i8 %2164 to i32
%2166 = add nsw i32 %2161, %2165
%2167 = load i8*, i8** %5
%2168 = getelementptr inbounds i8, i8* %2167, i64 28
%2169 = load i8, i8* %2168
%2170 = zext i8 %2169 to i32
%2171 = shl i32 %2170, 8
%2172 = load i8*, i8** %5
%2173 = getelementptr inbounds i8, i8* %2172, i64 29
%2174 = load i8, i8* %2173
%2175 = zext i8 %2174 to i32
%2176 = add nsw i32 %2171, %2175
%2177 = load i8*, i8** %5
%2178 = getelementptr inbounds i8, i8* %2177, i64 30
%2179 = load i8, i8* %2178
%2180 = zext i8 %2179 to i32
%2181 = shl i32 %2180, 8
%2182 = load i8*, i8** %5
%2183 = getelementptr inbounds i8, i8* %2182, i64 31
%2184 = load i8, i8* %2183
%2185 = zext i8 %2184 to i32
%2186 = add nsw i32 %2181, %2185
%2187 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %2156, i32 %2166, i32 %2176, i32 %2186)
br label %3259
2188: ; preds = %3
%2189 = load i8*, i8** %5
%2190 = getelementptr inbounds i8, i8* %2189, i64 2
%2191 = load i8, i8* %2190
%2192 = zext i8 %2191 to i32
%2193 = ashr i32 %2192, 2
%2194 = and i32 %2193, 15
%2195 = load i8*, i8** %5
%2196 = getelementptr inbounds i8, i8* %2195, i64 2
%2197 = load i8, i8* %2196
%2198 = zext i8 %2197 to i32
%2199 = and i32 %2198, 2
%2200 = icmp ne i32 %2199, 0
%2201 = xor i1 %2200, true
%2202 = xor i1 %2201, true
%2203 = zext i1 %2202 to i32
%2204 = load i8*, i8** %5
%2205 = getelementptr inbounds i8, i8* %2204, i64 2
%2206 = load i8, i8* %2205
%2207 = zext i8 %2206 to i32
%2208 = and i32 %2207, 1
%2209 = icmp ne i32 %2208, 0
%2210 = xor i1 %2209, true
%2211 = xor i1 %2210, true
%2212 = zext i1 %2211 to i32
%2213 = load i32, i32* %4
%2214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2194, i32 %2203, i32 %2212, i32 %2213)
%2215 = load i32, i32* %6
%2216 = icmp slt i32 %2215, 8
br i1 %2216, label %2217, label %2221
2217: ; preds = %2188
%2218 = load i32, i32* %6
%2219 = sub nsw i32 %2218, 4
%2220 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2219)
br label %3259
2221: ; preds = %2188
%2222 = load i8*, i8** %5
%2223 = getelementptr inbounds i8, i8* %2222, i64 4
%2224 = load i8, i8* %2223
%2225 = zext i8 %2224 to i32
%2226 = and i32 %2225, 1
%2227 = icmp ne i32 %2226, 0
%2228 = xor i1 %2227, true
%2229 = xor i1 %2228, true
%2230 = zext i1 %2229 to i32
%2231 = load i8*, i8** %5
%2232 = getelementptr inbounds i8, i8* %2231, i64 6
%2233 = load i8, i8* %2232
%2234 = zext i8 %2233 to i32
%2235 = and i32 %2234, 1
%2236 = icmp ne i32 %2235, 0
%2237 = xor i1 %2236, true
%2238 = xor i1 %2237, true
%2239 = zext i1 %2238 to i32
%2240 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.62, i64 0, i64 0), i32 %2230, i32 %2239)
br label %3259
2241: ; preds = %3
%2242 = load i8*, i8** %5
%2243 = getelementptr inbounds i8, i8* %2242, i64 2
%2244 = load i8, i8* %2243
%2245 = zext i8 %2244 to i32
%2246 = ashr i32 %2245, 2
%2247 = and i32 %2246, 15
%2248 = load i8*, i8** %5
%2249 = getelementptr inbounds i8, i8* %2248, i64 2
%2250 = load i8, i8* %2249
%2251 = zext i8 %2250 to i32
%2252 = and i32 %2251, 2
%2253 = icmp ne i32 %2252, 0
%2254 = xor i1 %2253, true
%2255 = xor i1 %2254, true
%2256 = zext i1 %2255 to i32
%2257 = load i8*, i8** %5
%2258 = getelementptr inbounds i8, i8* %2257, i64 2
%2259 = load i8, i8* %2258
%2260 = zext i8 %2259 to i32
%2261 = and i32 %2260, 1
%2262 = icmp ne i32 %2261, 0
%2263 = xor i1 %2262, true
%2264 = xor i1 %2263, true
%2265 = zext i1 %2264 to i32
%2266 = load i32, i32* %4
%2267 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2247, i32 %2256, i32 %2265, i32 %2266)
%2268 = load i32, i32* %6
%2269 = icmp slt i32 %2268, 8
br i1 %2269, label %2270, label %2274
2270: ; preds = %2241
%2271 = load i32, i32* %6
%2272 = sub nsw i32 %2271, 4
%2273 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2272)
br label %3259
2274: ; preds = %2241
%2275 = load i8*, i8** %5
%2276 = getelementptr inbounds i8, i8* %2275, i64 4
%2277 = load i8, i8* %2276
%2278 = zext i8 %2277 to i32
%2279 = and i32 %2278, 1
%2280 = icmp ne i32 %2279, 0
%2281 = xor i1 %2280, true
%2282 = xor i1 %2281, true
%2283 = zext i1 %2282 to i32
%2284 = load i8*, i8** %5
%2285 = getelementptr inbounds i8, i8* %2284, i64 6
%2286 = load i8, i8* %2285
%2287 = zext i8 %2286 to i32
%2288 = and i32 %2287, 1
%2289 = icmp ne i32 %2288, 0
%2290 = xor i1 %2289, true
%2291 = xor i1 %2290, true
%2292 = zext i1 %2291 to i32
%2293 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.62, i64 0, i64 0), i32 %2283, i32 %2292)
br label %3259
2294: ; preds = %3
%2295 = load i8*, i8** %5
%2296 = getelementptr inbounds i8, i8* %2295, i64 2
%2297 = load i8, i8* %2296
%2298 = zext i8 %2297 to i32
%2299 = ashr i32 %2298, 2
%2300 = and i32 %2299, 15
%2301 = load i8*, i8** %5
%2302 = getelementptr inbounds i8, i8* %2301, i64 2
%2303 = load i8, i8* %2302
%2304 = zext i8 %2303 to i32
%2305 = and i32 %2304, 2
%2306 = icmp ne i32 %2305, 0
%2307 = xor i1 %2306, true
%2308 = xor i1 %2307, true
%2309 = zext i1 %2308 to i32
%2310 = load i8*, i8** %5
%2311 = getelementptr inbounds i8, i8* %2310, i64 2
%2312 = load i8, i8* %2311
%2313 = zext i8 %2312 to i32
%2314 = and i32 %2313, 1
%2315 = icmp ne i32 %2314, 0
%2316 = xor i1 %2315, true
%2317 = xor i1 %2316, true
%2318 = zext i1 %2317 to i32
%2319 = load i32, i32* %4
%2320 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2300, i32 %2309, i32 %2318, i32 %2319)
%2321 = load i32, i32* %6
%2322 = icmp slt i32 %2321, 8
br i1 %2322, label %2323, label %2327
2323: ; preds = %2294
%2324 = load i32, i32* %6
%2325 = sub nsw i32 %2324, 4
%2326 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2325)
br label %3259
2327: ; preds = %2294
%2328 = load i8*, i8** %5
%2329 = getelementptr inbounds i8, i8* %2328, i64 4
%2330 = load i8, i8* %2329
%2331 = zext i8 %2330 to i32
%2332 = and i32 %2331, 1
%2333 = icmp ne i32 %2332, 0
%2334 = xor i1 %2333, true
%2335 = xor i1 %2334, true
%2336 = zext i1 %2335 to i32
%2337 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.63, i64 0, i64 0), i32 %2336)
br label %3259
2338: ; preds = %3
%2339 = load i8*, i8** %5
%2340 = getelementptr inbounds i8, i8* %2339, i64 2
%2341 = load i8, i8* %2340
%2342 = zext i8 %2341 to i32
%2343 = ashr i32 %2342, 2
%2344 = and i32 %2343, 15
%2345 = load i8*, i8** %5
%2346 = getelementptr inbounds i8, i8* %2345, i64 2
%2347 = load i8, i8* %2346
%2348 = zext i8 %2347 to i32
%2349 = and i32 %2348, 2
%2350 = icmp ne i32 %2349, 0
%2351 = xor i1 %2350, true
%2352 = xor i1 %2351, true
%2353 = zext i1 %2352 to i32
%2354 = load i8*, i8** %5
%2355 = getelementptr inbounds i8, i8* %2354, i64 2
%2356 = load i8, i8* %2355
%2357 = zext i8 %2356 to i32
%2358 = and i32 %2357, 1
%2359 = icmp ne i32 %2358, 0
%2360 = xor i1 %2359, true
%2361 = xor i1 %2360, true
%2362 = zext i1 %2361 to i32
%2363 = load i32, i32* %4
%2364 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2344, i32 %2353, i32 %2362, i32 %2363)
%2365 = load i32, i32* %6
%2366 = icmp slt i32 %2365, 8
br i1 %2366, label %2367, label %2371
2367: ; preds = %2338
%2368 = load i32, i32* %6
%2369 = sub nsw i32 %2368, 4
%2370 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2369)
br label %3259
2371: ; preds = %2338
%2372 = load i8*, i8** %5
%2373 = getelementptr inbounds i8, i8* %2372, i64 4
%2374 = load i8, i8* %2373
%2375 = zext i8 %2374 to i32
%2376 = and i32 %2375, 1
%2377 = icmp ne i32 %2376, 0
%2378 = xor i1 %2377, true
%2379 = xor i1 %2378, true
%2380 = zext i1 %2379 to i32
%2381 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.64, i64 0, i64 0), i32 %2380)
br label %3259
2382: ; preds = %3
%2383 = load i8*, i8** %5
%2384 = getelementptr inbounds i8, i8* %2383, i64 2
%2385 = load i8, i8* %2384
%2386 = zext i8 %2385 to i32
%2387 = ashr i32 %2386, 2
%2388 = and i32 %2387, 15
%2389 = load i8*, i8** %5
%2390 = getelementptr inbounds i8, i8* %2389, i64 2
%2391 = load i8, i8* %2390
%2392 = zext i8 %2391 to i32
%2393 = and i32 %2392, 2
%2394 = icmp ne i32 %2393, 0
%2395 = xor i1 %2394, true
%2396 = xor i1 %2395, true
%2397 = zext i1 %2396 to i32
%2398 = load i8*, i8** %5
%2399 = getelementptr inbounds i8, i8* %2398, i64 2
%2400 = load i8, i8* %2399
%2401 = zext i8 %2400 to i32
%2402 = and i32 %2401, 1
%2403 = icmp ne i32 %2402, 0
%2404 = xor i1 %2403, true
%2405 = xor i1 %2404, true
%2406 = zext i1 %2405 to i32
%2407 = load i32, i32* %4
%2408 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2388, i32 %2397, i32 %2406, i32 %2407)
%2409 = load i32, i32* %6
%2410 = icmp slt i32 %2409, 8
br i1 %2410, label %2411, label %2415
2411: ; preds = %2382
%2412 = load i32, i32* %6
%2413 = sub nsw i32 %2412, 4
%2414 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2413)
br label %3259
2415: ; preds = %2382
%2416 = load i8*, i8** %5
%2417 = getelementptr inbounds i8, i8* %2416, i64 4
%2418 = load i8, i8* %2417
%2419 = zext i8 %2418 to i32
%2420 = and i32 %2419, 1
%2421 = icmp ne i32 %2420, 0
%2422 = xor i1 %2421, true
%2423 = xor i1 %2422, true
%2424 = zext i1 %2423 to i32
%2425 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.65, i64 0, i64 0), i32 %2424)
br label %3259
2426: ; preds = %3
%2427 = load i8*, i8** %5
%2428 = getelementptr inbounds i8, i8* %2427, i64 2
%2429 = load i8, i8* %2428
%2430 = zext i8 %2429 to i32
%2431 = ashr i32 %2430, 2
%2432 = and i32 %2431, 15
%2433 = load i8*, i8** %5
%2434 = getelementptr inbounds i8, i8* %2433, i64 2
%2435 = load i8, i8* %2434
%2436 = zext i8 %2435 to i32
%2437 = and i32 %2436, 2
%2438 = icmp ne i32 %2437, 0
%2439 = xor i1 %2438, true
%2440 = xor i1 %2439, true
%2441 = zext i1 %2440 to i32
%2442 = load i8*, i8** %5
%2443 = getelementptr inbounds i8, i8* %2442, i64 2
%2444 = load i8, i8* %2443
%2445 = zext i8 %2444 to i32
%2446 = and i32 %2445, 1
%2447 = icmp ne i32 %2446, 0
%2448 = xor i1 %2447, true
%2449 = xor i1 %2448, true
%2450 = zext i1 %2449 to i32
%2451 = load i32, i32* %4
%2452 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2432, i32 %2441, i32 %2450, i32 %2451)
%2453 = load i32, i32* %6
%2454 = icmp slt i32 %2453, 8
br i1 %2454, label %2455, label %2459
2455: ; preds = %2426
%2456 = load i32, i32* %6
%2457 = sub nsw i32 %2456, 4
%2458 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2457)
br label %3259
2459: ; preds = %2426
%2460 = load i8*, i8** %5
%2461 = getelementptr inbounds i8, i8* %2460, i64 4
%2462 = load i8, i8* %2461
%2463 = zext i8 %2462 to i32
%2464 = and i32 %2463, 16
%2465 = icmp ne i32 %2464, 0
%2466 = xor i1 %2465, true
%2467 = xor i1 %2466, true
%2468 = zext i1 %2467 to i32
%2469 = load i8*, i8** %5
%2470 = getelementptr inbounds i8, i8* %2469, i64 4
%2471 = load i8, i8* %2470
%2472 = zext i8 %2471 to i32
%2473 = and i32 %2472, 4
%2474 = icmp ne i32 %2473, 0
%2475 = xor i1 %2474, true
%2476 = xor i1 %2475, true
%2477 = zext i1 %2476 to i32
%2478 = load i8*, i8** %5
%2479 = getelementptr inbounds i8, i8* %2478, i64 7
%2480 = load i8, i8* %2479
%2481 = zext i8 %2480 to i32
%2482 = and i32 %2481, 31
%2483 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.66, i64 0, i64 0), i32 %2468, i32 %2477, i32 %2482)
br label %3259
2484: ; preds = %3
%2485 = load i8*, i8** %5
%2486 = getelementptr inbounds i8, i8* %2485, i64 2
%2487 = load i8, i8* %2486
%2488 = zext i8 %2487 to i32
%2489 = ashr i32 %2488, 2
%2490 = and i32 %2489, 15
%2491 = load i8*, i8** %5
%2492 = getelementptr inbounds i8, i8* %2491, i64 2
%2493 = load i8, i8* %2492
%2494 = zext i8 %2493 to i32
%2495 = and i32 %2494, 2
%2496 = icmp ne i32 %2495, 0
%2497 = xor i1 %2496, true
%2498 = xor i1 %2497, true
%2499 = zext i1 %2498 to i32
%2500 = load i8*, i8** %5
%2501 = getelementptr inbounds i8, i8* %2500, i64 2
%2502 = load i8, i8* %2501
%2503 = zext i8 %2502 to i32
%2504 = and i32 %2503, 1
%2505 = icmp ne i32 %2504, 0
%2506 = xor i1 %2505, true
%2507 = xor i1 %2506, true
%2508 = zext i1 %2507 to i32
%2509 = load i32, i32* %4
%2510 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2490, i32 %2499, i32 %2508, i32 %2509)
%2511 = load i32, i32* %6
%2512 = icmp slt i32 %2511, 8
br i1 %2512, label %2513, label %2517
2513: ; preds = %2484
%2514 = load i32, i32* %6
%2515 = sub nsw i32 %2514, 4
%2516 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2515)
br label %3259
2517: ; preds = %2484
%2518 = load i8*, i8** %5
%2519 = getelementptr inbounds i8, i8* %2518, i64 4
%2520 = load i8, i8* %2519
%2521 = zext i8 %2520 to i32
%2522 = and i32 %2521, 4
%2523 = icmp ne i32 %2522, 0
%2524 = xor i1 %2523, true
%2525 = xor i1 %2524, true
%2526 = zext i1 %2525 to i32
%2527 = load i8*, i8** %5
%2528 = getelementptr inbounds i8, i8* %2527, i64 4
%2529 = load i8, i8* %2528
%2530 = zext i8 %2529 to i32
%2531 = and i32 %2530, 2
%2532 = icmp ne i32 %2531, 0
%2533 = xor i1 %2532, true
%2534 = xor i1 %2533, true
%2535 = zext i1 %2534 to i32
%2536 = load i8*, i8** %5
%2537 = getelementptr inbounds i8, i8* %2536, i64 4
%2538 = load i8, i8* %2537
%2539 = zext i8 %2538 to i32
%2540 = and i32 %2539, 1
%2541 = icmp ne i32 %2540, 0
%2542 = xor i1 %2541, true
%2543 = xor i1 %2542, true
%2544 = zext i1 %2543 to i32
%2545 = load i8*, i8** %5
%2546 = getelementptr inbounds i8, i8* %2545, i64 6
%2547 = load i8, i8* %2546
%2548 = zext i8 %2547 to i32
%2549 = shl i32 %2548, 8
%2550 = load i8*, i8** %5
%2551 = getelementptr inbounds i8, i8* %2550, i64 7
%2552 = load i8, i8* %2551
%2553 = zext i8 %2552 to i32
%2554 = add nsw i32 %2549, %2553
%2555 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.67, i64 0, i64 0), i32 %2526, i32 %2535, i32 %2544, i32 %2554)
br label %3259
2556: ; preds = %3
%2557 = load i8*, i8** %5
%2558 = getelementptr inbounds i8, i8* %2557, i64 2
%2559 = load i8, i8* %2558
%2560 = zext i8 %2559 to i32
%2561 = ashr i32 %2560, 2
%2562 = and i32 %2561, 15
%2563 = load i8*, i8** %5
%2564 = getelementptr inbounds i8, i8* %2563, i64 2
%2565 = load i8, i8* %2564
%2566 = zext i8 %2565 to i32
%2567 = and i32 %2566, 2
%2568 = icmp ne i32 %2567, 0
%2569 = xor i1 %2568, true
%2570 = xor i1 %2569, true
%2571 = zext i1 %2570 to i32
%2572 = load i8*, i8** %5
%2573 = getelementptr inbounds i8, i8* %2572, i64 2
%2574 = load i8, i8* %2573
%2575 = zext i8 %2574 to i32
%2576 = and i32 %2575, 1
%2577 = icmp ne i32 %2576, 0
%2578 = xor i1 %2577, true
%2579 = xor i1 %2578, true
%2580 = zext i1 %2579 to i32
%2581 = load i32, i32* %4
%2582 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2562, i32 %2571, i32 %2580, i32 %2581)
%2583 = load i32, i32* %6
%2584 = icmp slt i32 %2583, 4
br i1 %2584, label %2585, label %2589
2585: ; preds = %2556
%2586 = load i32, i32* %6
%2587 = sub nsw i32 %2586, 4
%2588 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2587)
br label %3259
2589: ; preds = %2556
%2590 = load i32, i32* %6
%2591 = icmp sgt i32 %2590, 4
br i1 %2591, label %2592, label %2603
2592: ; preds = %2589
%2593 = load i8*, i8** %5
%2594 = getelementptr inbounds i8, i8* %2593, i64 4
%2595 = load i8, i8* %2594
%2596 = zext i8 %2595 to i32
%2597 = and i32 %2596, 1
%2598 = icmp ne i32 %2597, 0
%2599 = xor i1 %2598, true
%2600 = xor i1 %2599, true
%2601 = zext i1 %2600 to i32
%2602 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.68, i64 0, i64 0), i32 %2601)
br label %2603
2603: ; preds = %2592, %2589
br label %3259
2604: ; preds = %3
%2605 = load i8*, i8** %5
%2606 = getelementptr inbounds i8, i8* %2605, i64 2
%2607 = load i8, i8* %2606
%2608 = zext i8 %2607 to i32
%2609 = ashr i32 %2608, 2
%2610 = and i32 %2609, 15
%2611 = load i8*, i8** %5
%2612 = getelementptr inbounds i8, i8* %2611, i64 2
%2613 = load i8, i8* %2612
%2614 = zext i8 %2613 to i32
%2615 = and i32 %2614, 2
%2616 = icmp ne i32 %2615, 0
%2617 = xor i1 %2616, true
%2618 = xor i1 %2617, true
%2619 = zext i1 %2618 to i32
%2620 = load i8*, i8** %5
%2621 = getelementptr inbounds i8, i8* %2620, i64 2
%2622 = load i8, i8* %2621
%2623 = zext i8 %2622 to i32
%2624 = and i32 %2623, 1
%2625 = icmp ne i32 %2624, 0
%2626 = xor i1 %2625, true
%2627 = xor i1 %2626, true
%2628 = zext i1 %2627 to i32
%2629 = load i32, i32* %4
%2630 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2610, i32 %2619, i32 %2628, i32 %2629)
%2631 = load i32, i32* %6
%2632 = icmp sgt i32 %2631, 7
br i1 %2632, label %2633, label %2654
2633: ; preds = %2604
%2634 = load i8*, i8** %5
%2635 = getelementptr inbounds i8, i8* %2634, i64 4
%2636 = load i8, i8* %2635
%2637 = zext i8 %2636 to i32
%2638 = and i32 %2637, 1
%2639 = icmp ne i32 %2638, 0
%2640 = xor i1 %2639, true
%2641 = xor i1 %2640, true
%2642 = zext i1 %2641 to i32
%2643 = load i8*, i8** %5
%2644 = getelementptr inbounds i8, i8* %2643, i64 6
%2645 = load i8, i8* %2644
%2646 = zext i8 %2645 to i32
%2647 = shl i32 %2646, 8
%2648 = load i8*, i8** %5
%2649 = getelementptr inbounds i8, i8* %2648, i64 7
%2650 = load i8, i8* %2649
%2651 = zext i8 %2650 to i32
%2652 = add nsw i32 %2647, %2651
%2653 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.69, i64 0, i64 0), i32 %2642, i32 %2652)
br label %2654
2654: ; preds = %2633, %2604
br label %3259
2655: ; preds = %3
%2656 = load i8*, i8** %5
%2657 = getelementptr inbounds i8, i8* %2656, i64 2
%2658 = load i8, i8* %2657
%2659 = zext i8 %2658 to i32
%2660 = ashr i32 %2659, 2
%2661 = and i32 %2660, 15
%2662 = load i8*, i8** %5
%2663 = getelementptr inbounds i8, i8* %2662, i64 2
%2664 = load i8, i8* %2663
%2665 = zext i8 %2664 to i32
%2666 = and i32 %2665, 2
%2667 = icmp ne i32 %2666, 0
%2668 = xor i1 %2667, true
%2669 = xor i1 %2668, true
%2670 = zext i1 %2669 to i32
%2671 = load i8*, i8** %5
%2672 = getelementptr inbounds i8, i8* %2671, i64 2
%2673 = load i8, i8* %2672
%2674 = zext i8 %2673 to i32
%2675 = and i32 %2674, 1
%2676 = icmp ne i32 %2675, 0
%2677 = xor i1 %2676, true
%2678 = xor i1 %2677, true
%2679 = zext i1 %2678 to i32
%2680 = load i32, i32* %4
%2681 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2661, i32 %2670, i32 %2679, i32 %2680)
%2682 = load i32, i32* %6
%2683 = icmp slt i32 %2682, 8
br i1 %2683, label %2684, label %2688
2684: ; preds = %2655
%2685 = load i32, i32* %6
%2686 = sub nsw i32 %2685, 4
%2687 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2686)
br label %3259
2688: ; preds = %2655
%2689 = load i8*, i8** %5
%2690 = getelementptr inbounds i8, i8* %2689, i64 7
%2691 = load i8, i8* %2690
%2692 = zext i8 %2691 to i32
%2693 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.70, i64 0, i64 0), i32 %2692)
br label %3259
2694: ; preds = %3
%2695 = load i8*, i8** %5
%2696 = getelementptr inbounds i8, i8* %2695, i64 2
%2697 = load i8, i8* %2696
%2698 = zext i8 %2697 to i32
%2699 = ashr i32 %2698, 2
%2700 = and i32 %2699, 15
%2701 = load i8*, i8** %5
%2702 = getelementptr inbounds i8, i8* %2701, i64 2
%2703 = load i8, i8* %2702
%2704 = zext i8 %2703 to i32
%2705 = and i32 %2704, 2
%2706 = icmp ne i32 %2705, 0
%2707 = xor i1 %2706, true
%2708 = xor i1 %2707, true
%2709 = zext i1 %2708 to i32
%2710 = load i8*, i8** %5
%2711 = getelementptr inbounds i8, i8* %2710, i64 2
%2712 = load i8, i8* %2711
%2713 = zext i8 %2712 to i32
%2714 = and i32 %2713, 1
%2715 = icmp ne i32 %2714, 0
%2716 = xor i1 %2715, true
%2717 = xor i1 %2716, true
%2718 = zext i1 %2717 to i32
%2719 = load i32, i32* %4
%2720 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2700, i32 %2709, i32 %2718, i32 %2719)
%2721 = load i32, i32* %6
%2722 = icmp slt i32 %2721, 8
br i1 %2722, label %2723, label %2727
2723: ; preds = %2694
%2724 = load i32, i32* %6
%2725 = sub nsw i32 %2724, 4
%2726 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2725)
br label %3259
2727: ; preds = %2694
%2728 = load i8*, i8** %5
%2729 = getelementptr inbounds i8, i8* %2728, i64 4
%2730 = load i8, i8* %2729
%2731 = zext i8 %2730 to i32
%2732 = and i32 %2731, 16
%2733 = icmp ne i32 %2732, 0
%2734 = xor i1 %2733, true
%2735 = xor i1 %2734, true
%2736 = zext i1 %2735 to i32
%2737 = load i8*, i8** %5
%2738 = getelementptr inbounds i8, i8* %2737, i64 4
%2739 = load i8, i8* %2738
%2740 = zext i8 %2739 to i32
%2741 = and i32 %2740, 8
%2742 = icmp ne i32 %2741, 0
%2743 = xor i1 %2742, true
%2744 = xor i1 %2743, true
%2745 = zext i1 %2744 to i32
%2746 = load i8*, i8** %5
%2747 = getelementptr inbounds i8, i8* %2746, i64 4
%2748 = load i8, i8* %2747
%2749 = zext i8 %2748 to i32
%2750 = and i32 %2749, 4
%2751 = icmp ne i32 %2750, 0
%2752 = xor i1 %2751, true
%2753 = xor i1 %2752, true
%2754 = zext i1 %2753 to i32
%2755 = load i8*, i8** %5
%2756 = getelementptr inbounds i8, i8* %2755, i64 4
%2757 = load i8, i8* %2756
%2758 = zext i8 %2757 to i32
%2759 = and i32 %2758, 2
%2760 = icmp ne i32 %2759, 0
%2761 = xor i1 %2760, true
%2762 = xor i1 %2761, true
%2763 = zext i1 %2762 to i32
%2764 = load i8*, i8** %5
%2765 = getelementptr inbounds i8, i8* %2764, i64 4
%2766 = load i8, i8* %2765
%2767 = zext i8 %2766 to i32
%2768 = and i32 %2767, 1
%2769 = icmp ne i32 %2768, 0
%2770 = xor i1 %2769, true
%2771 = xor i1 %2770, true
%2772 = zext i1 %2771 to i32
%2773 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.71, i64 0, i64 0), i32 %2736, i32 %2745, i32 %2754, i32 %2763, i32 %2772)
br label %3259
2774: ; preds = %3
%2775 = load i8*, i8** %5
%2776 = getelementptr inbounds i8, i8* %2775, i64 2
%2777 = load i8, i8* %2776
%2778 = zext i8 %2777 to i32
%2779 = ashr i32 %2778, 2
%2780 = and i32 %2779, 15
%2781 = load i8*, i8** %5
%2782 = getelementptr inbounds i8, i8* %2781, i64 2
%2783 = load i8, i8* %2782
%2784 = zext i8 %2783 to i32
%2785 = and i32 %2784, 2
%2786 = icmp ne i32 %2785, 0
%2787 = xor i1 %2786, true
%2788 = xor i1 %2787, true
%2789 = zext i1 %2788 to i32
%2790 = load i8*, i8** %5
%2791 = getelementptr inbounds i8, i8* %2790, i64 2
%2792 = load i8, i8* %2791
%2793 = zext i8 %2792 to i32
%2794 = and i32 %2793, 1
%2795 = icmp ne i32 %2794, 0
%2796 = xor i1 %2795, true
%2797 = xor i1 %2796, true
%2798 = zext i1 %2797 to i32
%2799 = load i32, i32* %4
%2800 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2780, i32 %2789, i32 %2798, i32 %2799)
%2801 = load i32, i32* %6
%2802 = sub nsw i32 %2801, 4
store i32 %2802, i32* %8
store i32 127, i32* %9
%2803 = load i32, i32* %8
%2804 = load i32, i32* %9
%2805 = icmp slt i32 %2803, %2804
br i1 %2805, label %2806, label %2808
2806: ; preds = %2774
%2807 = load i32, i32* %8
br label %2810
2808: ; preds = %2774
%2809 = load i32, i32* %9
br label %2810
2810: ; preds = %2808, %2806
%2811 = phi i32 [ %2807, %2806 ], [ %2809, %2808 ]
store i32 %2811, i32* %9
%2812 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
%2813 = load i8*, i8** %5
%2814 = getelementptr inbounds i8, i8* %2813, i64 4
%2815 = load i32, i32* %9
%2816 = sext i32 %2815 to i64
%2817 = call i8* @strncpy(i8* %2812, i8* %2814, i64 %2816)
%2818 = load i32, i32* %9
%2819 = sext i32 %2818 to i64
%2820 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 %2819
store i8 0, i8* %2820
%2821 = getelementptr inbounds [128 x i8], [128 x i8]* %11, i64 0, i64 0
%2822 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.72, i64 0, i64 0), i8* %2821)
br label %3259
2823: ; preds = %3
%2824 = load i8*, i8** %5
%2825 = getelementptr inbounds i8, i8* %2824, i64 2
%2826 = load i8, i8* %2825
%2827 = zext i8 %2826 to i32
%2828 = ashr i32 %2827, 2
%2829 = and i32 %2828, 15
%2830 = load i8*, i8** %5
%2831 = getelementptr inbounds i8, i8* %2830, i64 2
%2832 = load i8, i8* %2831
%2833 = zext i8 %2832 to i32
%2834 = and i32 %2833, 2
%2835 = icmp ne i32 %2834, 0
%2836 = xor i1 %2835, true
%2837 = xor i1 %2836, true
%2838 = zext i1 %2837 to i32
%2839 = load i8*, i8** %5
%2840 = getelementptr inbounds i8, i8* %2839, i64 2
%2841 = load i8, i8* %2840
%2842 = zext i8 %2841 to i32
%2843 = and i32 %2842, 1
%2844 = icmp ne i32 %2843, 0
%2845 = xor i1 %2844, true
%2846 = xor i1 %2845, true
%2847 = zext i1 %2846 to i32
%2848 = load i32, i32* %4
%2849 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2829, i32 %2838, i32 %2847, i32 %2848)
%2850 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.73, i64 0, i64 0))
store i32 4, i32* %7
br label %2851
2851: ; preds = %2890, %2823
%2852 = load i32, i32* %7
%2853 = load i32, i32* %6
%2854 = icmp slt i32 %2852, %2853
br i1 %2854, label %2855, label %2893
2855: ; preds = %2851
%2856 = load i8*, i8** %5
%2857 = load i32, i32* %7
%2858 = sext i32 %2857 to i64
%2859 = getelementptr inbounds i8, i8* %2856, i64 %2858
%2860 = load i8, i8* %2859
%2861 = zext i8 %2860 to i32
%2862 = shl i32 %2861, 24
%2863 = load i8*, i8** %5
%2864 = load i32, i32* %7
%2865 = add nsw i32 %2864, 1
%2866 = sext i32 %2865 to i64
%2867 = getelementptr inbounds i8, i8* %2863, i64 %2866
%2868 = load i8, i8* %2867
%2869 = zext i8 %2868 to i32
%2870 = shl i32 %2869, 16
%2871 = add i32 %2862, %2870
%2872 = load i8*, i8** %5
%2873 = load i32, i32* %7
%2874 = add nsw i32 %2873, 2
%2875 = sext i32 %2874 to i64
%2876 = getelementptr inbounds i8, i8* %2872, i64 %2875
%2877 = load i8, i8* %2876
%2878 = zext i8 %2877 to i32
%2879 = shl i32 %2878, 8
%2880 = add i32 %2871, %2879
%2881 = load i8*, i8** %5
%2882 = load i32, i32* %7
%2883 = add nsw i32 %2882, 3
%2884 = sext i32 %2883 to i64
%2885 = getelementptr inbounds i8, i8* %2881, i64 %2884
%2886 = load i8, i8* %2885
%2887 = zext i8 %2886 to i32
%2888 = add i32 %2880, %2887
%2889 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.74, i64 0, i64 0), i32 %2888)
br label %2890
2890: ; preds = %2855
%2891 = load i32, i32* %7
%2892 = add nsw i32 %2891, 4
store i32 %2892, i32* %7
br label %2851
2893: ; preds = %2851
br label %3259
2894: ; preds = %3
%2895 = load i8*, i8** %5
%2896 = getelementptr inbounds i8, i8* %2895, i64 2
%2897 = load i8, i8* %2896
%2898 = zext i8 %2897 to i32
%2899 = ashr i32 %2898, 2
%2900 = and i32 %2899, 15
%2901 = load i8*, i8** %5
%2902 = getelementptr inbounds i8, i8* %2901, i64 2
%2903 = load i8, i8* %2902
%2904 = zext i8 %2903 to i32
%2905 = and i32 %2904, 2
%2906 = icmp ne i32 %2905, 0
%2907 = xor i1 %2906, true
%2908 = xor i1 %2907, true
%2909 = zext i1 %2908 to i32
%2910 = load i8*, i8** %5
%2911 = getelementptr inbounds i8, i8* %2910, i64 2
%2912 = load i8, i8* %2911
%2913 = zext i8 %2912 to i32
%2914 = and i32 %2913, 1
%2915 = icmp ne i32 %2914, 0
%2916 = xor i1 %2915, true
%2917 = xor i1 %2916, true
%2918 = zext i1 %2917 to i32
%2919 = load i32, i32* %4
%2920 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2900, i32 %2909, i32 %2918, i32 %2919)
%2921 = load i32, i32* %6
%2922 = icmp slt i32 %2921, 8
br i1 %2922, label %2923, label %2927
2923: ; preds = %2894
%2924 = load i32, i32* %6
%2925 = sub nsw i32 %2924, 4
%2926 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2925)
br label %3259
2927: ; preds = %2894
%2928 = load i8*, i8** %5
%2929 = getelementptr inbounds i8, i8* %2928, i64 7
%2930 = load i8, i8* %2929
%2931 = zext i8 %2930 to i32
%2932 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.75, i64 0, i64 0), i32 %2931)
br label %3259
2933: ; preds = %3
%2934 = load i8*, i8** %5
%2935 = getelementptr inbounds i8, i8* %2934, i64 2
%2936 = load i8, i8* %2935
%2937 = zext i8 %2936 to i32
%2938 = ashr i32 %2937, 2
%2939 = and i32 %2938, 15
%2940 = load i8*, i8** %5
%2941 = getelementptr inbounds i8, i8* %2940, i64 2
%2942 = load i8, i8* %2941
%2943 = zext i8 %2942 to i32
%2944 = and i32 %2943, 2
%2945 = icmp ne i32 %2944, 0
%2946 = xor i1 %2945, true
%2947 = xor i1 %2946, true
%2948 = zext i1 %2947 to i32
%2949 = load i8*, i8** %5
%2950 = getelementptr inbounds i8, i8* %2949, i64 2
%2951 = load i8, i8* %2950
%2952 = zext i8 %2951 to i32
%2953 = and i32 %2952, 1
%2954 = icmp ne i32 %2953, 0
%2955 = xor i1 %2954, true
%2956 = xor i1 %2955, true
%2957 = zext i1 %2956 to i32
%2958 = load i32, i32* %4
%2959 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2939, i32 %2948, i32 %2957, i32 %2958)
%2960 = load i32, i32* %6
%2961 = icmp slt i32 %2960, 20
br i1 %2961, label %2962, label %2966
2962: ; preds = %2933
%2963 = load i32, i32* %6
%2964 = sub nsw i32 %2963, 4
%2965 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %2964)
br label %3259
2966: ; preds = %2933
%2967 = load i8*, i8** %5
%2968 = getelementptr inbounds i8, i8* %2967, i64 4
%2969 = load i8*, i8** %5
%2970 = getelementptr inbounds i8, i8* %2969, i64 6
%2971 = load i8*, i8** %5
%2972 = getelementptr inbounds i8, i8* %2971, i64 8
%2973 = load i8*, i8** %5
%2974 = getelementptr inbounds i8, i8* %2973, i64 10
%2975 = load i8*, i8** %5
%2976 = getelementptr inbounds i8, i8* %2975, i64 12
%2977 = load i8*, i8** %5
%2978 = getelementptr inbounds i8, i8* %2977, i64 14
%2979 = load i8*, i8** %5
%2980 = getelementptr inbounds i8, i8* %2979, i64 16
%2981 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.76, i64 0, i64 0), i8* %2968, i8* %2970, i8* %2972, i8* %2974, i8* %2976, i8* %2978, i8* %2980)
br label %3259
2982: ; preds = %3
%2983 = load i8*, i8** %5
%2984 = getelementptr inbounds i8, i8* %2983, i64 2
%2985 = load i8, i8* %2984
%2986 = zext i8 %2985 to i32
%2987 = ashr i32 %2986, 2
%2988 = and i32 %2987, 15
%2989 = load i8*, i8** %5
%2990 = getelementptr inbounds i8, i8* %2989, i64 2
%2991 = load i8, i8* %2990
%2992 = zext i8 %2991 to i32
%2993 = and i32 %2992, 2
%2994 = icmp ne i32 %2993, 0
%2995 = xor i1 %2994, true
%2996 = xor i1 %2995, true
%2997 = zext i1 %2996 to i32
%2998 = load i8*, i8** %5
%2999 = getelementptr inbounds i8, i8* %2998, i64 2
%3000 = load i8, i8* %2999
%3001 = zext i8 %3000 to i32
%3002 = and i32 %3001, 1
%3003 = icmp ne i32 %3002, 0
%3004 = xor i1 %3003, true
%3005 = xor i1 %3004, true
%3006 = zext i1 %3005 to i32
%3007 = load i32, i32* %4
%3008 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %2988, i32 %2997, i32 %3006, i32 %3007)
%3009 = load i32, i32* %6
%3010 = icmp slt i32 %3009, 8
br i1 %3010, label %3011, label %3015
3011: ; preds = %2982
%3012 = load i32, i32* %6
%3013 = sub nsw i32 %3012, 4
%3014 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %3013)
br label %3259
3015: ; preds = %2982
%3016 = load i8*, i8** %5
%3017 = getelementptr inbounds i8, i8* %3016, i64 4
%3018 = load i8, i8* %3017
%3019 = zext i8 %3018 to i32
%3020 = and i32 %3019, 1
%3021 = icmp ne i32 %3020, 0
%3022 = xor i1 %3021, true
%3023 = xor i1 %3022, true
%3024 = zext i1 %3023 to i32
%3025 = load i8*, i8** %5
%3026 = getelementptr inbounds i8, i8* %3025, i64 5
%3027 = load i8, i8* %3026
%3028 = zext i8 %3027 to i32
%3029 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.77, i64 0, i64 0), i32 %3024, i32 %3028)
%3030 = load i8*, i8** %5
%3031 = getelementptr inbounds i8, i8* %3030, i64 6
%3032 = load i8, i8* %3031
%3033 = zext i8 %3032 to i32
%3034 = and i32 %3033, 15
%3035 = load i8*, i8** %5
%3036 = getelementptr inbounds i8, i8* %3035, i64 7
%3037 = load i8, i8* %3036
%3038 = zext i8 %3037 to i32
%3039 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.78, i64 0, i64 0), i32 %3034, i32 %3038)
br label %3259
3040: ; preds = %3
%3041 = load i8*, i8** %5
%3042 = getelementptr inbounds i8, i8* %3041, i64 2
%3043 = load i8, i8* %3042
%3044 = zext i8 %3043 to i32
%3045 = ashr i32 %3044, 2
%3046 = and i32 %3045, 15
%3047 = load i8*, i8** %5
%3048 = getelementptr inbounds i8, i8* %3047, i64 2
%3049 = load i8, i8* %3048
%3050 = zext i8 %3049 to i32
%3051 = and i32 %3050, 2
%3052 = icmp ne i32 %3051, 0
%3053 = xor i1 %3052, true
%3054 = xor i1 %3053, true
%3055 = zext i1 %3054 to i32
%3056 = load i8*, i8** %5
%3057 = getelementptr inbounds i8, i8* %3056, i64 2
%3058 = load i8, i8* %3057
%3059 = zext i8 %3058 to i32
%3060 = and i32 %3059, 1
%3061 = icmp ne i32 %3060, 0
%3062 = xor i1 %3061, true
%3063 = xor i1 %3062, true
%3064 = zext i1 %3063 to i32
%3065 = load i32, i32* %4
%3066 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %3046, i32 %3055, i32 %3064, i32 %3065)
%3067 = load i32, i32* %6
%3068 = icmp slt i32 %3067, 8
br i1 %3068, label %3069, label %3073
3069: ; preds = %3040
%3070 = load i32, i32* %6
%3071 = sub nsw i32 %3070, 4
%3072 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %3071)
br label %3259
3073: ; preds = %3040
%3074 = load i8*, i8** %5
%3075 = getelementptr inbounds i8, i8* %3074, i64 4
%3076 = load i8, i8* %3075
%3077 = zext i8 %3076 to i32
%3078 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.79, i64 0, i64 0), i32 %3077)
br label %3259
3079: ; preds = %3
%3080 = load i8*, i8** %5
%3081 = getelementptr inbounds i8, i8* %3080, i64 2
%3082 = load i8, i8* %3081
%3083 = zext i8 %3082 to i32
%3084 = ashr i32 %3083, 2
%3085 = and i32 %3084, 15
%3086 = load i8*, i8** %5
%3087 = getelementptr inbounds i8, i8* %3086, i64 2
%3088 = load i8, i8* %3087
%3089 = zext i8 %3088 to i32
%3090 = and i32 %3089, 2
%3091 = icmp ne i32 %3090, 0
%3092 = xor i1 %3091, true
%3093 = xor i1 %3092, true
%3094 = zext i1 %3093 to i32
%3095 = load i8*, i8** %5
%3096 = getelementptr inbounds i8, i8* %3095, i64 2
%3097 = load i8, i8* %3096
%3098 = zext i8 %3097 to i32
%3099 = and i32 %3098, 1
%3100 = icmp ne i32 %3099, 0
%3101 = xor i1 %3100, true
%3102 = xor i1 %3101, true
%3103 = zext i1 %3102 to i32
%3104 = load i32, i32* %4
%3105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %3085, i32 %3094, i32 %3103, i32 %3104)
%3106 = load i32, i32* %6
%3107 = icmp slt i32 %3106, 8
br i1 %3107, label %3108, label %3112
3108: ; preds = %3079
%3109 = load i32, i32* %6
%3110 = sub nsw i32 %3109, 4
%3111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %3110)
br label %3259
3112: ; preds = %3079
%3113 = load i8*, i8** %5
%3114 = getelementptr inbounds i8, i8* %3113, i64 5
%3115 = load i8, i8* %3114
%3116 = zext i8 %3115 to i32
%3117 = ashr i32 %3116, 4
%3118 = and i32 %3117, 15
%3119 = load i8*, i8** %5
%3120 = getelementptr inbounds i8, i8* %3119, i64 5
%3121 = load i8, i8* %3120
%3122 = zext i8 %3121 to i32
%3123 = and i32 %3122, 15
%3124 = load i8*, i8** %5
%3125 = getelementptr inbounds i8, i8* %3124, i64 6
%3126 = load i8, i8* %3125
%3127 = zext i8 %3126 to i32
%3128 = and i32 %3127, 3
%3129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.80, i64 0, i64 0), i32 %3118, i32 %3123, i32 %3128)
br label %3259
3130: ; preds = %3
%3131 = load i8*, i8** %5
%3132 = getelementptr inbounds i8, i8* %3131, i64 2
%3133 = load i8, i8* %3132
%3134 = zext i8 %3133 to i32
%3135 = ashr i32 %3134, 2
%3136 = and i32 %3135, 15
%3137 = load i8*, i8** %5
%3138 = getelementptr inbounds i8, i8* %3137, i64 2
%3139 = load i8, i8* %3138
%3140 = zext i8 %3139 to i32
%3141 = and i32 %3140, 2
%3142 = icmp ne i32 %3141, 0
%3143 = xor i1 %3142, true
%3144 = xor i1 %3143, true
%3145 = zext i1 %3144 to i32
%3146 = load i8*, i8** %5
%3147 = getelementptr inbounds i8, i8* %3146, i64 2
%3148 = load i8, i8* %3147
%3149 = zext i8 %3148 to i32
%3150 = and i32 %3149, 1
%3151 = icmp ne i32 %3150, 0
%3152 = xor i1 %3151, true
%3153 = xor i1 %3152, true
%3154 = zext i1 %3153 to i32
%3155 = load i32, i32* %4
%3156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %3136, i32 %3145, i32 %3154, i32 %3155)
%3157 = load i32, i32* %6
%3158 = icmp slt i32 %3157, 8
br i1 %3158, label %3159, label %3163
3159: ; preds = %3130
%3160 = load i32, i32* %6
%3161 = sub nsw i32 %3160, 4
%3162 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %3161)
br label %3259
3163: ; preds = %3130
%3164 = load i8*, i8** %5
%3165 = getelementptr inbounds i8, i8* %3164, i64 4
%3166 = load i8, i8* %3165
%3167 = zext i8 %3166 to i32
%3168 = and i32 %3167, 128
%3169 = icmp ne i32 %3168, 0
%3170 = xor i1 %3169, true
%3171 = xor i1 %3170, true
%3172 = zext i1 %3171 to i32
%3173 = load i8*, i8** %5
%3174 = getelementptr inbounds i8, i8* %3173, i64 4
%3175 = load i8, i8* %3174
%3176 = zext i8 %3175 to i32
%3177 = and i32 %3176, 64
%3178 = icmp ne i32 %3177, 0
%3179 = xor i1 %3178, true
%3180 = xor i1 %3179, true
%3181 = zext i1 %3180 to i32
%3182 = load i8*, i8** %5
%3183 = getelementptr inbounds i8, i8* %3182, i64 4
%3184 = load i8, i8* %3183
%3185 = zext i8 %3184 to i32
%3186 = and i32 %3185, 1
%3187 = icmp ne i32 %3186, 0
%3188 = xor i1 %3187, true
%3189 = xor i1 %3188, true
%3190 = zext i1 %3189 to i32
%3191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.81, i64 0, i64 0), i32 %3172, i32 %3181, i32 %3190)
%3192 = load i8*, i8** %5
%3193 = getelementptr inbounds i8, i8* %3192, i64 5
%3194 = load i8, i8* %3193
%3195 = zext i8 %3194 to i32
store i32 %3195, i32* %8
%3196 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.82, i64 0, i64 0))
store i32 6, i32* %7
br label %3197
3197: ; preds = %3223, %3163
%3198 = load i32, i32* %8
%3199 = icmp sgt i32 %3198, 0
br i1 %3199, label %3200, label %3204
3200: ; preds = %3197
%3201 = load i32, i32* %7
%3202 = load i32, i32* %6
%3203 = icmp slt i32 %3201, %3202
br label %3204
3204: ; preds = %3200, %3197
%3205 = phi i1 [ false, %3197 ], [ %3203, %3200 ]
br i1 %3205, label %3206, label %3228
3206: ; preds = %3204
%3207 = load i8*, i8** %5
%3208 = load i32, i32* %7
%3209 = sext i32 %3208 to i64
%3210 = getelementptr inbounds i8, i8* %3207, i64 %3209
%3211 = load i8, i8* %3210
%3212 = zext i8 %3211 to i32
%3213 = shl i32 %3212, 8
%3214 = load i8*, i8** %5
%3215 = load i32, i32* %7
%3216 = add nsw i32 %3215, 1
%3217 = sext i32 %3216 to i64
%3218 = getelementptr inbounds i8, i8* %3214, i64 %3217
%3219 = load i8, i8* %3218
%3220 = zext i8 %3219 to i32
%3221 = add i32 %3213, %3220
%3222 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.34, i64 0, i64 0), i32 %3221)
br label %3223
3223: ; preds = %3206
%3224 = load i32, i32* %8
%3225 = add nsw i32 %3224, -1
store i32 %3225, i32* %8
%3226 = load i32, i32* %7
%3227 = add nsw i32 %3226, 2
store i32 %3227, i32* %7
br label %3197
3228: ; preds = %3204
br label %3259
3229: ; preds = %3
%3230 = load i32, i32* %4
%3231 = load i8*, i8** %5
%3232 = getelementptr inbounds i8, i8* %3231, i64 2
%3233 = load i8, i8* %3232
%3234 = zext i8 %3233 to i32
%3235 = ashr i32 %3234, 2
%3236 = and i32 %3235, 15
%3237 = load i8*, i8** %5
%3238 = getelementptr inbounds i8, i8* %3237, i64 2
%3239 = load i8, i8* %3238
%3240 = zext i8 %3239 to i32
%3241 = and i32 %3240, 2
%3242 = icmp ne i32 %3241, 0
%3243 = xor i1 %3242, true
%3244 = xor i1 %3243, true
%3245 = zext i1 %3244 to i32
%3246 = load i8*, i8** %5
%3247 = getelementptr inbounds i8, i8* %3246, i64 2
%3248 = load i8, i8* %3247
%3249 = zext i8 %3248 to i32
%3250 = and i32 %3249, 1
%3251 = icmp ne i32 %3250, 0
%3252 = xor i1 %3251, true
%3253 = xor i1 %3252, true
%3254 = zext i1 %3253 to i32
%3255 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.83, i64 0, i64 0), i32 %3230, i32 %3236, i32 %3245, i32 %3254)
%3256 = load i8*, i8** %5
%3257 = load i32, i32* %6
%3258 = call i32 (i8*, i32, i32, ...) bitcast (i32 (...)* @dStrHex to i32 (i8*, i32, i32, ...)*)(i8* %3256, i32 %3257, i32 1)
br label %3259
3259: ; preds = %3229, %3228, %3159, %3112, %3108, %3073, %3069, %3015, %3011, %2966, %2962, %2927, %2923, %2893, %2810, %2727, %2723, %2688, %2684, %2654, %2603, %2585, %2517, %2513, %2459, %2455, %2415, %2411, %2371, %2367, %2327, %2323, %2274, %2270, %2221, %2217, %2051, %2047, %1891, %1887, %1847, %1843, %1785, %1781, %1746, %1742, %1697, %1693, %1663, %1636, %1569, %1565, %1453, %1449, %1353, %1349, %1282, %1278, %1238, %1234, %1176, %1172, %1118, %1114, %1084, %982, %978, %948, %907, %816, %751, %655, %651, %621, %534, %530, %474, %430, %426, %359, %355, %286, %264, %215, %211, %181, %111, %81
ret void
}

LLVM IR (-O2):
@.str.1 = [47 x i8] c" version=%d, persist=%d, current=%d [0x%x]\0A\00"
@.str.3 = [33 x i8] c" profile: %s , currentP=%d\0A\00"
@.str.4 = [40 x i8] c" additional length [%d] too short\0A\00"
@.str.5 = [12 x i8] c"unspecified\00"
@.str.6 = [12 x i8] c"SCSI family\00"
@.str.7 = [6 x i8] c"ATAPI\00"
@.str.8 = [17 x i8] c"IEEE 1394 - 1995\00"
@.str.9 = [11 x i8] c"IEEE 1394A\00"
@.str.10 = [14 x i8] c"Fibre channel\00"
@.str.11 = [11 x i8] c"IEEE 1394B\00"
@.str.12 = [13 x i8] c"Serial ATAPI\00"
@.str.13 = [19 x i8] c"USB (both 1 and 2)\00"
@.str.14 = [14 x i8] c"vendor unique\00"
@.str.15 = [7 x i8] c"[0x%x]\00"
@.str.16 = [38 x i8] c" Physical interface standard: %s\00"
@.str.17 = [19 x i8] c", INQ2=%d, DBE=%d\0A\00"
@.str.19 = [28 x i8] c" OCEvent=%d, ASYNC=%d\0A\00"
@.str.20 = [16 x i8] c"Caddy/slot type\00"
@.str.21 = [10 x i8] c"Tray type\00"
@.str.22 = [12 x i8] c"Pop-up type\00"
@.str.23 = [52 x i8] c"Embedded changer with individually changeable discs\00"
@.str.24 = [34 x i8] c"Embedded changer using a magazine\00"
@.str.25 = [29 x i8] c" Loading mechanism: %s\0A\00"
@.str.26 = [53 x i8] c" Load=%d, Eject=%d, Prevent jumper=%d, Lock=%d\0A\00"
@.str.27 = [42 x i8] c" DWP=%d, WDCB=%d, SPWP=%d, SSWPP=%d\0A\00"
@.str.28 = [53 x i8] c" Logical block size=0x%x, blocking=0x%x, PP=%d\0A\00"
@.str.29 = [39 x i8] c" DAP=%d, C2 flags=%d, CD-Text=%d\0A\00"
@.str.30 = [42 x i8] c" MULTI110=%d, Dual-RW=%d, Dual-R=%d\0A\00"
@.str.31 = [68 x i8] c" Last lba=0x%x, Logical block size=0x%x, blocking=0x%x, PP=%d\0A\00"
@.str.32 = [65 x i8] c" Data block types supported=0x%x, TRIO=%d, ARSV=%d, BUF=%d\0A\00"
@.str.33 = [31 x i8] c" Number of link sizes=%d\0A\00"
@.str.34 = [12 x i8] c" %d\0A\00"
@.str.35 = [62 x i8] c" BD-RE: RENoSA=%d, Expand=%d, QCert=%d, Cert=%d, FRF=%d\0A\00"
@.str.36 = [20 x i8] c" BD-R: RRM=%d\0A\00"
@.str.37 = [14 x i8] c" SSA=%d\0A\00"
@.str.38 = [43 x i8] c" DVD+Write=%d, DVD+Read=%d, Write=%d\0A\00"
@.str.39 = [73 x i8] c" DRT-DM=%d, number of DBI cache zones=0x%x, number of entries=0x%x\0A\00"
@.str.40 = [47 x i8] c" Write=%d, Quick start=%d, Close only=%d\0A\00"
@.str.41 = [16 x i8] c" Write=%d\0A\00"
@.str.42 = [51 x i8] c" DSDG=%d, DSDR=%d, Intermediate=%d, Blank=%d\0A\00"
@.str.43 = [54 x i8] c" BUF=%d, R-W raw=%d, R-W pack=%d, Test write=%d\0A\00"
@.str.44 = [57 x i8] c" CD-RW=%d, R-W sub-code=%d, Data type supported=%d\0A\00"
@.str.45 = [41 x i8] c" BUF=%d, SAO=%d, Raw MS=%d, Raw=%d\0A\00"
@.str.46 = [39 x i8] c" Test write=%d, CD-RW=%d, R-W=%d\0A\00"
@.str.47 = [37 x i8] c" Maximum cue sheet length=0x%x\0A\00"
@.str.48 = [51 x i8] c" BUF=%d, RDL=%d, Test write=%d, DVD-RW SL=%d\0A\00"
@.str.49 = [15 x i8] c" CLJB=%d\0A\00"
@.str.50 = [28 x i8] c" Buffer block size=%d\0A\00"
@.str.51 = [51 x i8] c" CD-RW media sub-type support (bitmask)=0x%x\0A\00"
@.str.52 = [47 x i8] c" write=%d, quick_start=%d, close_only=%d\0A\00"
@.str.53 = [16 x i8] c" write=%d\0A\00"
@.str.55 = [64 x i8] c" Class 0=0x%x, Class 1=0x%x, Class 2=0x%x, Class 3=0x%x\0A\00"
@.str.58 = [15 x i8] c" SVNR=%d\0A\00"
@.str.62 = [34 x i8] c" HD DVD-R=%d, HD DVD-RAM=%d\0A\00"
@.str.63 = [14 x i8] c" BGP=%d\0A\00"
@.str.64 = [13 x i8] c" RI=%d\0A\00"
@.str.65 = [13 x i8] c" PP=%d\0A\00"
@.str.66 = [46 x i8] c" SCC=%d, SDP=%d, highest slot number=%d\0A\00"
@.str.67 = [58 x i8] c" Scan=%d, SCM=%d, SV=%d, number of volume levels=%d\0A\00"
@.str.68 = [13 x i8] c" M5=%d\0A\00"
@.str.69 = [34 x i8] c" Group 3=%d, unit length=%d\0A\00"
@.str.70 = [22 x i8] c" CSS version=%d\0A\00"
@.str.71 = [48 x i8] c" RBCB=%d, SCS=%d, MP2A=%d, WSPD=%d, SW=%d\0A\00"
@.str.72 = [31 x i8] c" Drive serial number: %s\0A\00"
@.str.74 = [14 x i8] c" 0x%x\0A\00"
@.str.75 = [23 x i8] c" CPRM version=%d\0A\00"
@.str.76 = [41 x i8] c" %.2s%.2s/%.2s/%.2s %.2s:%.2s:%.2s\0A\00"
@.str.77 = [48 x i8] c" BNG=%d, Block count for binding nonce=%d\0A\00"
@.str.78 = [43 x i8] c" Number of AGIDs=%d, AACS version=%d\0A\00"
@.str.79 = [65 x i8] c" Maximum number of scrambled extent information entries=%d\0A\00"
@.str.80 = [65 x i8] c" BD CPS major:minor version number=%d:%d, max open SACs=%d\0A\00"
@.str.81 = [30 x i8] c" PSAU=%d, LOSPB=%d, ME=%d\0A\00"
@.str.83 = [63 x i8] c" Unknown feature [0x%x], version=%d persist=%d, current=%d\0A\00"
@str = [23 x i8] c" Profile numbers:\00"
@str.84 = [27 x i8] c" Disc control blocks:\00"
@str.85 = [39 x i8] c" Bitmaps for BD-RE write support:\00"
@str.86 = [38 x i8] c" Bitmaps for BD-R write support:\00"
@str.87 = [40 x i8] c" Bitmaps for BD-ROM write support:\00"
@str.88 = [38 x i8] c" Bitmaps for BD-RE read support:\00"
@str.89 = [37 x i8] c" Bitmaps for BD-R read support:\00"
@str.90 = [39 x i8] c" Bitmaps for BD-ROM read support:\00"
@str.91 = [63 x i8] c" available profiles [more recent typically higher in list]:\00"
@reltable.decode_feature = [6 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([16 x i8]* @.str.20 to i64), i64 ptrtoint ([6 x i32]* @reltable.decode_feature to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([10 x i8]* @.str.21 to i64), i64 ptrtoint ([6 x i32]* @reltable.decode_feature to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([12 x i8]* @.str.22 to i64), i64 ptrtoint ([6 x i32]* @reltable.decode_feature to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([16 x i8]* @.str.20 to i64), i64 ptrtoint ([6 x i32]* @reltable.decode_feature to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([52 x i8]* @.str.23 to i64), i64 ptrtoint ([6 x i32]* @reltable.decode_feature to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([34 x i8]* @.str.24 to i64), i64 ptrtoint ([6 x i32]* @reltable.decode_feature to i64)) to i32)]
define void @decode_feature(i32 %0, i8* %1, i32 %2) {
%4 = alloca [128 x i8]
%5 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 0
switch i32 %0, label %1582 [
i32 0, label %6
i32 1, label %39
i32 2, label %97
i32 3, label %119
i32 4, label %162
i32 16, label %188
i32 29, label %234
i32 34, label %234
i32 38, label %234
i32 39, label %234
i32 53, label %234
i32 56, label %234
i32 66, label %234
i32 256, label %234
i32 265, label %234
i32 272, label %234
i32 275, label %234
i32 30, label %244
i32 31, label %267
i32 32, label %290
i32 33, label %354
i32 35, label %402
i32 36, label %436
i32 37, label %453
i32 40, label %499
i32 41, label %520
i32 42, label %551
i32 43, label %577
i32 44, label %597
i32 45, label %623
i32 46, label %664
i32 47, label %713
i32 51, label %740
i32 52, label %771
i32 55, label %795
i32 58, label %814
i32 59, label %840
i32 64, label %860
i32 65, label %977
i32 80, label %1099
i32 81, label %1123
i32 82, label %1147
i32 128, label %1167
i32 257, label %1187
i32 258, label %1207
i32 259, label %1234
i32 260, label %1266
i32 261, label %1288
i32 262, label %1313
i32 263, label %1332
i32 264, label %1360
i32 266, label %1378
i32 267, label %1417
i32 268, label %1436
i32 269, label %1459
i32 270, label %1490
i32 288, label %1509
i32 322, label %1534
]
6: ; preds = %3
%7 = getelementptr inbounds i8, i8* %1, i64 2
%8 = load i8, i8* %7
%9 = zext i8 %8 to i32
%10 = lshr i32 %9, 2
%11 = and i32 %10, 15
%12 = lshr i32 %9, 1
%13 = and i32 %12, 1
%14 = and i32 %9, 1
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %11, i32 %13, i32 %14, i32 0)
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.91, i64 0, i64 0))
%17 = icmp sgt i32 %2, 4
br i1 %17, label %18, label %1593
18: ; preds = %6, %18
%19 = phi i64 [ %36, %18 ], [ 4, %6 ]
%20 = getelementptr inbounds i8, i8* %1, i64 %19
%21 = load i8, i8* %20
%22 = zext i8 %21 to i32
%23 = shl nuw nsw i32 %22, 8
%24 = or i64 %19, 1
%25 = getelementptr inbounds i8, i8* %1, i64 %24
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = or i32 %23, %27
%29 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @get_profile_str to i32 (i32, i8*, ...)*)(i32 %28, i8* %5)
%30 = or i64 %19, 2
%31 = getelementptr inbounds i8, i8* %1, i64 %30
%32 = load i8, i8* %31
%33 = and i8 %32, 1
%34 = zext i8 %33 to i32
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i32 %29, i32 %34)
%36 = add nuw i64 %19, 4
%37 = trunc i64 %36 to i32
%38 = icmp slt i32 %37, %2
br i1 %38, label %18, label %1593
39: ; preds = %3
%40 = getelementptr inbounds i8, i8* %1, i64 2
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = lshr i32 %42, 2
%44 = and i32 %43, 15
%45 = lshr i32 %42, 1
%46 = and i32 %45, 1
%47 = and i32 %42, 1
%48 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %44, i32 %46, i32 %47, i32 1)
%49 = icmp slt i32 %2, 8
br i1 %49, label %50, label %53
50: ; preds = %39
%51 = add nsw i32 %2, -4
%52 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %51)
br label %1593
53: ; preds = %39
%54 = getelementptr inbounds i8, i8* %1, i64 4
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = shl nuw i32 %56, 24
%58 = getelementptr inbounds i8, i8* %1, i64 5
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = shl nuw nsw i32 %60, 16
%62 = or i32 %61, %57
%63 = getelementptr inbounds i8, i8* %1, i64 6
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = shl nuw nsw i32 %65, 8
%67 = or i32 %62, %66
%68 = getelementptr inbounds i8, i8* %1, i64 7
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = or i32 %67, %70
switch i32 %71, label %81 [
i32 0, label %83
i32 1, label %72
i32 2, label %73
i32 3, label %74
i32 4, label %75
i32 5, label %76
i32 6, label %77
i32 7, label %78
i32 8, label %79
i32 65535, label %80
]
72: ; preds = %53
br label %83
73: ; preds = %53
br label %83
74: ; preds = %53
br label %83
75: ; preds = %53
br label %83
76: ; preds = %53
br label %83
77: ; preds = %53
br label %83
78: ; preds = %53
br label %83
79: ; preds = %53
br label %83
80: ; preds = %53
br label %83
81: ; preds = %53
%82 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %5, i64 128, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i32 %71)
br label %83
83: ; preds = %53, %81, %80, %79, %78, %77, %76, %75, %74, %73, %72
%84 = phi i8* [ %5, %81 ], [ getelementptr inbounds ([14 x i8], [14 x i8]* @.str.14, i64 0, i64 0), %80 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.13, i64 0, i64 0), %79 ], [ getelementptr inbounds ([13 x i8], [13 x i8]* @.str.12, i64 0, i64 0), %78 ], [ getelementptr inbounds ([11 x i8], [11 x i8]* @.str.11, i64 0, i64 0), %77 ], [ getelementptr inbounds ([14 x i8], [14 x i8]* @.str.10, i64 0, i64 0), %76 ], [ getelementptr inbounds ([11 x i8], [11 x i8]* @.str.9, i64 0, i64 0), %75 ], [ getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), %74 ], [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), %73 ], [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), %72 ], [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0), %53 ]
%85 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.16, i64 0, i64 0), i8* %84)
%86 = icmp ugt i32 %2, 8
br i1 %86, label %87, label %95
87: ; preds = %83
%88 = getelementptr inbounds i8, i8* %1, i64 8
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
%91 = lshr i32 %90, 1
%92 = and i32 %91, 1
%93 = and i32 %90, 1
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.17, i64 0, i64 0), i32 %92, i32 %93)
br label %1593
95: ; preds = %83
%96 = call i32 @putchar(i32 10)
br label %1593
97: ; preds = %3
%98 = getelementptr inbounds i8, i8* %1, i64 2
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = lshr i32 %100, 2
%102 = and i32 %101, 15
%103 = lshr i32 %100, 1
%104 = and i32 %103, 1
%105 = and i32 %100, 1
%106 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %102, i32 %104, i32 %105, i32 2)
%107 = icmp slt i32 %2, 8
br i1 %107, label %108, label %111
108: ; preds = %97
%109 = add nsw i32 %2, -4
%110 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %109)
br label %1593
111: ; preds = %97
%112 = getelementptr inbounds i8, i8* %1, i64 4
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = lshr i32 %114, 1
%116 = and i32 %115, 1
%117 = and i32 %114, 1
%118 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.19, i64 0, i64 0), i32 %116, i32 %117)
br label %1593
119: ; preds = %3
%120 = getelementptr inbounds i8, i8* %1, i64 2
%121 = load i8, i8* %120
%122 = zext i8 %121 to i32
%123 = lshr i32 %122, 2
%124 = and i32 %123, 15
%125 = lshr i32 %122, 1
%126 = and i32 %125, 1
%127 = and i32 %122, 1
%128 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %124, i32 %126, i32 %127, i32 3)
%129 = icmp slt i32 %2, 8
br i1 %129, label %130, label %133
130: ; preds = %119
%131 = add nsw i32 %2, -4
%132 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %131)
br label %1593
133: ; preds = %119
%134 = getelementptr inbounds i8, i8* %1, i64 4
%135 = load i8, i8* %134
%136 = lshr i8 %135, 5
%137 = zext i8 %136 to i32
%138 = icmp ult i8 %135, -64
br i1 %138, label %141, label %139
139: ; preds = %141, %133
%140 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %5, i64 128, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i32 %137)
br label %149
141: ; preds = %133
%142 = lshr i8 55, %136
%143 = and i8 %142, 1
%144 = icmp eq i8 %143, 0
br i1 %144, label %139, label %145
145: ; preds = %141
%146 = zext i8 %136 to i64
%147 = shl i64 %146, 2
%148 = call i8* @llvm.load.relative.i64(i8* bitcast ([6 x i32]* @reltable.decode_feature to i8*), i64 %147)
br label %149
149: ; preds = %145, %139
%150 = phi i8* [ %5, %139 ], [ %148, %145 ]
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.25, i64 0, i64 0), i8* %150)
%152 = load i8, i8* %134
%153 = zext i8 %152 to i32
%154 = lshr i32 %153, 4
%155 = and i32 %154, 1
%156 = lshr i32 %153, 3
%157 = and i32 %156, 1
%158 = lshr i32 %153, 2
%159 = and i32 %158, 1
%160 = and i32 %153, 1
%161 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.26, i64 0, i64 0), i32 %155, i32 %157, i32 %159, i32 %160)
br label %1593
162: ; preds = %3
%163 = getelementptr inbounds i8, i8* %1, i64 2
%164 = load i8, i8* %163
%165 = zext i8 %164 to i32
%166 = lshr i32 %165, 2
%167 = and i32 %166, 15
%168 = lshr i32 %165, 1
%169 = and i32 %168, 1
%170 = and i32 %165, 1
%171 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %167, i32 %169, i32 %170, i32 4)
%172 = icmp slt i32 %2, 8
br i1 %172, label %173, label %176
173: ; preds = %162
%174 = add nsw i32 %2, -4
%175 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %174)
br label %1593
176: ; preds = %162
%177 = getelementptr inbounds i8, i8* %1, i64 4
%178 = load i8, i8* %177
%179 = zext i8 %178 to i32
%180 = lshr i32 %179, 3
%181 = and i32 %180, 1
%182 = lshr i32 %179, 2
%183 = and i32 %182, 1
%184 = lshr i32 %179, 1
%185 = and i32 %184, 1
%186 = and i32 %179, 1
%187 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.27, i64 0, i64 0), i32 %181, i32 %183, i32 %185, i32 %186)
br label %1593
188: ; preds = %3
%189 = getelementptr inbounds i8, i8* %1, i64 2
%190 = load i8, i8* %189
%191 = zext i8 %190 to i32
%192 = lshr i32 %191, 2
%193 = and i32 %192, 15
%194 = lshr i32 %191, 1
%195 = and i32 %194, 1
%196 = and i32 %191, 1
%197 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %193, i32 %195, i32 %196, i32 16)
%198 = icmp slt i32 %2, 12
br i1 %198, label %199, label %202
199: ; preds = %188
%200 = add nsw i32 %2, -4
%201 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %200)
br label %1593
202: ; preds = %188
%203 = getelementptr inbounds i8, i8* %1, i64 4
%204 = load i8, i8* %203
%205 = zext i8 %204 to i32
%206 = shl nuw i32 %205, 24
%207 = getelementptr inbounds i8, i8* %1, i64 5
%208 = load i8, i8* %207
%209 = zext i8 %208 to i32
%210 = shl nuw nsw i32 %209, 16
%211 = or i32 %210, %206
%212 = getelementptr inbounds i8, i8* %1, i64 6
%213 = load i8, i8* %212
%214 = zext i8 %213 to i32
%215 = shl nuw nsw i32 %214, 8
%216 = or i32 %211, %215
%217 = getelementptr inbounds i8, i8* %1, i64 7
%218 = load i8, i8* %217
%219 = zext i8 %218 to i32
%220 = or i32 %216, %219
%221 = getelementptr inbounds i8, i8* %1, i64 8
%222 = load i8, i8* %221
%223 = zext i8 %222 to i32
%224 = shl nuw nsw i32 %223, 8
%225 = getelementptr inbounds i8, i8* %1, i64 9
%226 = load i8, i8* %225
%227 = zext i8 %226 to i32
%228 = or i32 %224, %227
%229 = getelementptr inbounds i8, i8* %1, i64 10
%230 = load i8, i8* %229
%231 = and i8 %230, 1
%232 = zext i8 %231 to i32
%233 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.28, i64 0, i64 0), i32 %220, i32 %228, i32 %232)
br label %1593
234: ; preds = %3, %3, %3, %3, %3, %3, %3, %3, %3, %3, %3
%235 = getelementptr inbounds i8, i8* %1, i64 2
%236 = load i8, i8* %235
%237 = zext i8 %236 to i32
%238 = lshr i32 %237, 2
%239 = and i32 %238, 15
%240 = lshr i32 %237, 1
%241 = and i32 %240, 1
%242 = and i32 %237, 1
%243 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %239, i32 %241, i32 %242, i32 %0)
br label %1593
244: ; preds = %3
%245 = getelementptr inbounds i8, i8* %1, i64 2
%246 = load i8, i8* %245
%247 = zext i8 %246 to i32
%248 = lshr i32 %247, 2
%249 = and i32 %248, 15
%250 = lshr i32 %247, 1
%251 = and i32 %250, 1
%252 = and i32 %247, 1
%253 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %249, i32 %251, i32 %252, i32 30)
%254 = icmp slt i32 %2, 8
br i1 %254, label %255, label %258
255: ; preds = %244
%256 = add nsw i32 %2, -4
%257 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %256)
br label %1593
258: ; preds = %244
%259 = getelementptr inbounds i8, i8* %1, i64 4
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = lshr i32 %261, 7
%263 = lshr i32 %261, 1
%264 = and i32 %263, 1
%265 = and i32 %261, 1
%266 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.29, i64 0, i64 0), i32 %262, i32 %264, i32 %265)
br label %1593
267: ; preds = %3
%268 = getelementptr inbounds i8, i8* %1, i64 2
%269 = load i8, i8* %268
%270 = zext i8 %269 to i32
%271 = lshr i32 %270, 2
%272 = and i32 %271, 15
%273 = lshr i32 %270, 1
%274 = and i32 %273, 1
%275 = and i32 %270, 1
%276 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %272, i32 %274, i32 %275, i32 31)
%277 = icmp sgt i32 %2, 7
br i1 %277, label %278, label %1593
278: ; preds = %267
%279 = getelementptr inbounds i8, i8* %1, i64 4
%280 = load i8, i8* %279
%281 = and i8 %280, 1
%282 = zext i8 %281 to i32
%283 = getelementptr inbounds i8, i8* %1, i64 6
%284 = load i8, i8* %283
%285 = zext i8 %284 to i32
%286 = lshr i32 %285, 1
%287 = and i32 %286, 1
%288 = and i32 %285, 1
%289 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.30, i64 0, i64 0), i32 %282, i32 %287, i32 %288)
br label %1593
290: ; preds = %3
%291 = getelementptr inbounds i8, i8* %1, i64 2
%292 = load i8, i8* %291
%293 = zext i8 %292 to i32
%294 = lshr i32 %293, 2
%295 = and i32 %294, 15
%296 = lshr i32 %293, 1
%297 = and i32 %296, 1
%298 = and i32 %293, 1
%299 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %295, i32 %297, i32 %298, i32 32)
%300 = icmp slt i32 %2, 16
br i1 %300, label %301, label %304
301: ; preds = %290
%302 = add nsw i32 %2, -4
%303 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %302)
br label %1593
304: ; preds = %290
%305 = getelementptr inbounds i8, i8* %1, i64 4
%306 = load i8, i8* %305
%307 = zext i8 %306 to i32
%308 = shl nuw i32 %307, 24
%309 = getelementptr inbounds i8, i8* %1, i64 5
%310 = load i8, i8* %309
%311 = zext i8 %310 to i32
%312 = shl nuw nsw i32 %311, 16
%313 = or i32 %312, %308
%314 = getelementptr inbounds i8, i8* %1, i64 6
%315 = load i8, i8* %314
%316 = zext i8 %315 to i32
%317 = shl nuw nsw i32 %316, 8
%318 = or i32 %313, %317
%319 = getelementptr inbounds i8, i8* %1, i64 7
%320 = load i8, i8* %319
%321 = zext i8 %320 to i32
%322 = or i32 %318, %321
%323 = getelementptr inbounds i8, i8* %1, i64 8
%324 = load i8, i8* %323
%325 = zext i8 %324 to i32
%326 = shl nuw i32 %325, 24
%327 = getelementptr inbounds i8, i8* %1, i64 9
%328 = load i8, i8* %327
%329 = zext i8 %328 to i32
%330 = shl nuw nsw i32 %329, 16
%331 = or i32 %330, %326
%332 = getelementptr inbounds i8, i8* %1, i64 10
%333 = load i8, i8* %332
%334 = zext i8 %333 to i32
%335 = shl nuw nsw i32 %334, 8
%336 = or i32 %331, %335
%337 = getelementptr inbounds i8, i8* %1, i64 11
%338 = load i8, i8* %337
%339 = zext i8 %338 to i32
%340 = or i32 %336, %339
%341 = getelementptr inbounds i8, i8* %1, i64 12
%342 = load i8, i8* %341
%343 = zext i8 %342 to i32
%344 = shl nuw nsw i32 %343, 8
%345 = getelementptr inbounds i8, i8* %1, i64 13
%346 = load i8, i8* %345
%347 = zext i8 %346 to i32
%348 = or i32 %344, %347
%349 = getelementptr inbounds i8, i8* %1, i64 14
%350 = load i8, i8* %349
%351 = and i8 %350, 1
%352 = zext i8 %351 to i32
%353 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.31, i64 0, i64 0), i32 %322, i32 %340, i32 %348, i32 %352)
br label %1593
354: ; preds = %3
%355 = getelementptr inbounds i8, i8* %1, i64 2
%356 = load i8, i8* %355
%357 = zext i8 %356 to i32
%358 = lshr i32 %357, 2
%359 = and i32 %358, 15
%360 = lshr i32 %357, 1
%361 = and i32 %360, 1
%362 = and i32 %357, 1
%363 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %359, i32 %361, i32 %362, i32 33)
%364 = icmp slt i32 %2, 8
br i1 %364, label %365, label %368
365: ; preds = %354
%366 = add nsw i32 %2, -4
%367 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %366)
br label %1593
368: ; preds = %354
%369 = getelementptr inbounds i8, i8* %1, i64 4
%370 = load i8, i8* %369
%371 = zext i8 %370 to i32
%372 = shl nuw nsw i32 %371, 8
%373 = getelementptr inbounds i8, i8* %1, i64 5
%374 = load i8, i8* %373
%375 = zext i8 %374 to i32
%376 = or i32 %372, %375
%377 = getelementptr inbounds i8, i8* %1, i64 6
%378 = load i8, i8* %377
%379 = zext i8 %378 to i32
%380 = lshr i32 %379, 2
%381 = and i32 %380, 1
%382 = lshr i32 %379, 1
%383 = and i32 %382, 1
%384 = and i32 %379, 1
%385 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.32, i64 0, i64 0), i32 %376, i32 %381, i32 %383, i32 %384)
%386 = getelementptr inbounds i8, i8* %1, i64 7
%387 = load i8, i8* %386
%388 = zext i8 %387 to i32
%389 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.33, i64 0, i64 0), i32 %388)
%390 = icmp eq i8 %387, 0
br i1 %390, label %1593, label %391
391: ; preds = %368
%392 = zext i8 %387 to i64
br label %393
393: ; preds = %391, %393
%394 = phi i64 [ 0, %391 ], [ %400, %393 ]
%395 = add nuw nsw i64 %394, 8
%396 = getelementptr inbounds i8, i8* %1, i64 %395
%397 = load i8, i8* %396
%398 = zext i8 %397 to i32
%399 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.34, i64 0, i64 0), i32 %398)
%400 = add nuw nsw i64 %394, 1
%401 = icmp eq i64 %400, %392
br i1 %401, label %1593, label %393
402: ; preds = %3
%403 = getelementptr inbounds i8, i8* %1, i64 2
%404 = load i8, i8* %403
%405 = zext i8 %404 to i32
%406 = lshr i32 %405, 2
%407 = and i32 %406, 15
%408 = lshr i32 %405, 1
%409 = and i32 %408, 1
%410 = and i32 %405, 1
%411 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %407, i32 %409, i32 %410, i32 35)
%412 = icmp sgt i32 %2, 4
br i1 %412, label %413, label %1593
413: ; preds = %402
%414 = getelementptr inbounds i8, i8* %1, i64 4
%415 = load i8, i8* %414
%416 = zext i8 %415 to i32
%417 = lshr i32 %416, 3
%418 = and i32 %417, 1
%419 = lshr i32 %416, 2
%420 = and i32 %419, 1
%421 = lshr i32 %416, 1
%422 = and i32 %421, 1
%423 = and i32 %416, 1
%424 = getelementptr inbounds i8, i8* %1, i64 5
%425 = load i8, i8* %424
%426 = lshr i8 %425, 7
%427 = zext i8 %426 to i32
%428 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.35, i64 0, i64 0), i32 %418, i32 %420, i32 %422, i32 %423, i32 %427)
%429 = icmp ugt i32 %2, 8
br i1 %429, label %430, label %1593
430: ; preds = %413
%431 = getelementptr inbounds i8, i8* %1, i64 8
%432 = load i8, i8* %431
%433 = and i8 %432, 1
%434 = zext i8 %433 to i32
%435 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.36, i64 0, i64 0), i32 %434)
br label %1593
436: ; preds = %3
%437 = getelementptr inbounds i8, i8* %1, i64 2
%438 = load i8, i8* %437
%439 = zext i8 %438 to i32
%440 = lshr i32 %439, 2
%441 = and i32 %440, 15
%442 = lshr i32 %439, 1
%443 = and i32 %442, 1
%444 = and i32 %439, 1
%445 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %441, i32 %443, i32 %444, i32 36)
%446 = icmp sgt i32 %2, 4
br i1 %446, label %447, label %1593
447: ; preds = %436
%448 = getelementptr inbounds i8, i8* %1, i64 4
%449 = load i8, i8* %448
%450 = lshr i8 %449, 7
%451 = zext i8 %450 to i32
%452 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.37, i64 0, i64 0), i32 %451)
br label %1593
453: ; preds = %3
%454 = getelementptr inbounds i8, i8* %1, i64 2
%455 = load i8, i8* %454
%456 = zext i8 %455 to i32
%457 = lshr i32 %456, 2
%458 = and i32 %457, 15
%459 = lshr i32 %456, 1
%460 = and i32 %459, 1
%461 = and i32 %456, 1
%462 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %458, i32 %460, i32 %461, i32 37)
%463 = icmp slt i32 %2, 12
br i1 %463, label %464, label %467
464: ; preds = %453
%465 = add nsw i32 %2, -4
%466 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %465)
br label %1593
467: ; preds = %453
%468 = getelementptr inbounds i8, i8* %1, i64 4
%469 = load i8, i8* %468
%470 = zext i8 %469 to i32
%471 = shl nuw i32 %470, 24
%472 = getelementptr inbounds i8, i8* %1, i64 5
%473 = load i8, i8* %472
%474 = zext i8 %473 to i32
%475 = shl nuw nsw i32 %474, 16
%476 = or i32 %475, %471
%477 = getelementptr inbounds i8, i8* %1, i64 6
%478 = load i8, i8* %477
%479 = zext i8 %478 to i32
%480 = shl nuw nsw i32 %479, 8
%481 = or i32 %476, %480
%482 = getelementptr inbounds i8, i8* %1, i64 7
%483 = load i8, i8* %482
%484 = zext i8 %483 to i32
%485 = or i32 %481, %484
%486 = getelementptr inbounds i8, i8* %1, i64 8
%487 = load i8, i8* %486
%488 = zext i8 %487 to i32
%489 = shl nuw nsw i32 %488, 8
%490 = getelementptr inbounds i8, i8* %1, i64 9
%491 = load i8, i8* %490
%492 = zext i8 %491 to i32
%493 = or i32 %489, %492
%494 = getelementptr inbounds i8, i8* %1, i64 10
%495 = load i8, i8* %494
%496 = and i8 %495, 1
%497 = zext i8 %496 to i32
%498 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.28, i64 0, i64 0), i32 %485, i32 %493, i32 %497)
br label %1593
499: ; preds = %3
%500 = getelementptr inbounds i8, i8* %1, i64 2
%501 = load i8, i8* %500
%502 = zext i8 %501 to i32
%503 = lshr i32 %502, 2
%504 = and i32 %503, 15
%505 = lshr i32 %502, 1
%506 = and i32 %505, 1
%507 = and i32 %502, 1
%508 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %504, i32 %506, i32 %507, i32 40)
%509 = icmp sgt i32 %2, 4
br i1 %509, label %510, label %1593
510: ; preds = %499
%511 = getelementptr inbounds i8, i8* %1, i64 4
%512 = load i8, i8* %511
%513 = zext i8 %512 to i32
%514 = lshr i32 %513, 2
%515 = and i32 %514, 1
%516 = lshr i32 %513, 1
%517 = and i32 %516, 1
%518 = and i32 %513, 1
%519 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.38, i64 0, i64 0), i32 %515, i32 %517, i32 %518)
br label %1593
520: ; preds = %3
%521 = getelementptr inbounds i8, i8* %1, i64 2
%522 = load i8, i8* %521
%523 = zext i8 %522 to i32
%524 = lshr i32 %523, 2
%525 = and i32 %524, 15
%526 = lshr i32 %523, 1
%527 = and i32 %526, 1
%528 = and i32 %523, 1
%529 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %525, i32 %527, i32 %528, i32 41)
%530 = icmp slt i32 %2, 8
br i1 %530, label %531, label %534
531: ; preds = %520
%532 = add nsw i32 %2, -4
%533 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %532)
br label %1593
534: ; preds = %520
%535 = getelementptr inbounds i8, i8* %1, i64 4
%536 = load i8, i8* %535
%537 = and i8 %536, 1
%538 = zext i8 %537 to i32
%539 = getelementptr inbounds i8, i8* %1, i64 5
%540 = load i8, i8* %539
%541 = zext i8 %540 to i32
%542 = getelementptr inbounds i8, i8* %1, i64 6
%543 = load i8, i8* %542
%544 = zext i8 %543 to i32
%545 = shl nuw nsw i32 %544, 8
%546 = getelementptr inbounds i8, i8* %1, i64 7
%547 = load i8, i8* %546
%548 = zext i8 %547 to i32
%549 = or i32 %545, %548
%550 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.39, i64 0, i64 0), i32 %538, i32 %541, i32 %549)
br label %1593
551: ; preds = %3
%552 = getelementptr inbounds i8, i8* %1, i64 2
%553 = load i8, i8* %552
%554 = zext i8 %553 to i32
%555 = lshr i32 %554, 2
%556 = and i32 %555, 15
%557 = lshr i32 %554, 1
%558 = and i32 %557, 1
%559 = and i32 %554, 1
%560 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %556, i32 %558, i32 %559, i32 42)
%561 = icmp slt i32 %2, 8
br i1 %561, label %562, label %565
562: ; preds = %551
%563 = add nsw i32 %2, -4
%564 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %563)
br label %1593
565: ; preds = %551
%566 = getelementptr inbounds i8, i8* %1, i64 4
%567 = load i8, i8* %566
%568 = and i8 %567, 1
%569 = zext i8 %568 to i32
%570 = getelementptr inbounds i8, i8* %1, i64 5
%571 = load i8, i8* %570
%572 = zext i8 %571 to i32
%573 = lshr i32 %572, 1
%574 = and i32 %573, 1
%575 = and i32 %572, 1
%576 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.40, i64 0, i64 0), i32 %569, i32 %574, i32 %575)
br label %1593
577: ; preds = %3
%578 = getelementptr inbounds i8, i8* %1, i64 2
%579 = load i8, i8* %578
%580 = zext i8 %579 to i32
%581 = lshr i32 %580, 2
%582 = and i32 %581, 15
%583 = lshr i32 %580, 1
%584 = and i32 %583, 1
%585 = and i32 %580, 1
%586 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %582, i32 %584, i32 %585, i32 43)
%587 = icmp slt i32 %2, 8
br i1 %587, label %588, label %591
588: ; preds = %577
%589 = add nsw i32 %2, -4
%590 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %589)
br label %1593
591: ; preds = %577
%592 = getelementptr inbounds i8, i8* %1, i64 4
%593 = load i8, i8* %592
%594 = and i8 %593, 1
%595 = zext i8 %594 to i32
%596 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.41, i64 0, i64 0), i32 %595)
br label %1593
597: ; preds = %3
%598 = getelementptr inbounds i8, i8* %1, i64 2
%599 = load i8, i8* %598
%600 = zext i8 %599 to i32
%601 = lshr i32 %600, 2
%602 = and i32 %601, 15
%603 = lshr i32 %600, 1
%604 = and i32 %603, 1
%605 = and i32 %600, 1
%606 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %602, i32 %604, i32 %605, i32 44)
%607 = icmp slt i32 %2, 8
br i1 %607, label %608, label %611
608: ; preds = %597
%609 = add nsw i32 %2, -4
%610 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %609)
br label %1593
611: ; preds = %597
%612 = getelementptr inbounds i8, i8* %1, i64 4
%613 = load i8, i8* %612
%614 = zext i8 %613 to i32
%615 = lshr i32 %614, 3
%616 = and i32 %615, 1
%617 = lshr i32 %614, 2
%618 = and i32 %617, 1
%619 = lshr i32 %614, 1
%620 = and i32 %619, 1
%621 = and i32 %614, 1
%622 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.42, i64 0, i64 0), i32 %616, i32 %618, i32 %620, i32 %621)
br label %1593
623: ; preds = %3
%624 = getelementptr inbounds i8, i8* %1, i64 2
%625 = load i8, i8* %624
%626 = zext i8 %625 to i32
%627 = lshr i32 %626, 2
%628 = and i32 %627, 15
%629 = lshr i32 %626, 1
%630 = and i32 %629, 1
%631 = and i32 %626, 1
%632 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %628, i32 %630, i32 %631, i32 45)
%633 = icmp slt i32 %2, 8
br i1 %633, label %634, label %637
634: ; preds = %623
%635 = add nsw i32 %2, -4
%636 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %635)
br label %1593
637: ; preds = %623
%638 = getelementptr inbounds i8, i8* %1, i64 4
%639 = load i8, i8* %638
%640 = zext i8 %639 to i32
%641 = lshr i32 %640, 6
%642 = and i32 %641, 1
%643 = lshr i32 %640, 4
%644 = and i32 %643, 1
%645 = lshr i32 %640, 3
%646 = and i32 %645, 1
%647 = lshr i32 %640, 2
%648 = and i32 %647, 1
%649 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.43, i64 0, i64 0), i32 %642, i32 %644, i32 %646, i32 %648)
%650 = load i8, i8* %638
%651 = zext i8 %650 to i32
%652 = lshr i32 %651, 1
%653 = and i32 %652, 1
%654 = and i32 %651, 1
%655 = getelementptr inbounds i8, i8* %1, i64 6
%656 = load i8, i8* %655
%657 = zext i8 %656 to i32
%658 = shl nuw nsw i32 %657, 8
%659 = getelementptr inbounds i8, i8* %1, i64 7
%660 = load i8, i8* %659
%661 = zext i8 %660 to i32
%662 = or i32 %658, %661
%663 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @.str.44, i64 0, i64 0), i32 %653, i32 %654, i32 %662)
br label %1593
664: ; preds = %3
%665 = getelementptr inbounds i8, i8* %1, i64 2
%666 = load i8, i8* %665
%667 = zext i8 %666 to i32
%668 = lshr i32 %667, 2
%669 = and i32 %668, 15
%670 = lshr i32 %667, 1
%671 = and i32 %670, 1
%672 = and i32 %667, 1
%673 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %669, i32 %671, i32 %672, i32 46)
%674 = icmp slt i32 %2, 8
br i1 %674, label %675, label %678
675: ; preds = %664
%676 = add nsw i32 %2, -4
%677 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %676)
br label %1593
678: ; preds = %664
%679 = getelementptr inbounds i8, i8* %1, i64 4
%680 = load i8, i8* %679
%681 = zext i8 %680 to i32
%682 = lshr i32 %681, 6
%683 = and i32 %682, 1
%684 = lshr i32 %681, 5
%685 = and i32 %684, 1
%686 = lshr i32 %681, 4
%687 = and i32 %686, 1
%688 = lshr i32 %681, 3
%689 = and i32 %688, 1
%690 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.45, i64 0, i64 0), i32 %683, i32 %685, i32 %687, i32 %689)
%691 = load i8, i8* %679
%692 = zext i8 %691 to i32
%693 = lshr i32 %692, 2
%694 = and i32 %693, 1
%695 = lshr i32 %692, 1
%696 = and i32 %695, 1
%697 = and i32 %692, 1
%698 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.46, i64 0, i64 0), i32 %694, i32 %696, i32 %697)
%699 = getelementptr inbounds i8, i8* %1, i64 5
%700 = load i8, i8* %699
%701 = zext i8 %700 to i32
%702 = shl nuw nsw i32 %701, 16
%703 = getelementptr inbounds i8, i8* %1, i64 6
%704 = load i8, i8* %703
%705 = zext i8 %704 to i32
%706 = shl nuw nsw i32 %705, 8
%707 = or i32 %706, %702
%708 = getelementptr inbounds i8, i8* %1, i64 7
%709 = load i8, i8* %708
%710 = zext i8 %709 to i32
%711 = or i32 %707, %710
%712 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.47, i64 0, i64 0), i32 %711)
br label %1593
713: ; preds = %3
%714 = getelementptr inbounds i8, i8* %1, i64 2
%715 = load i8, i8* %714
%716 = zext i8 %715 to i32
%717 = lshr i32 %716, 2
%718 = and i32 %717, 15
%719 = lshr i32 %716, 1
%720 = and i32 %719, 1
%721 = and i32 %716, 1
%722 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %718, i32 %720, i32 %721, i32 47)
%723 = icmp slt i32 %2, 8
br i1 %723, label %724, label %727
724: ; preds = %713
%725 = add nsw i32 %2, -4
%726 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %725)
br label %1593
727: ; preds = %713
%728 = getelementptr inbounds i8, i8* %1, i64 4
%729 = load i8, i8* %728
%730 = zext i8 %729 to i32
%731 = lshr i32 %730, 6
%732 = and i32 %731, 1
%733 = lshr i32 %730, 3
%734 = and i32 %733, 1
%735 = lshr i32 %730, 2
%736 = and i32 %735, 1
%737 = lshr i32 %730, 1
%738 = and i32 %737, 1
%739 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.48, i64 0, i64 0), i32 %732, i32 %734, i32 %736, i32 %738)
br label %1593
740: ; preds = %3
%741 = getelementptr inbounds i8, i8* %1, i64 2
%742 = load i8, i8* %741
%743 = zext i8 %742 to i32
%744 = lshr i32 %743, 2
%745 = and i32 %744, 15
%746 = lshr i32 %743, 1
%747 = and i32 %746, 1
%748 = and i32 %743, 1
%749 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %745, i32 %747, i32 %748, i32 51)
%750 = icmp slt i32 %2, 8
br i1 %750, label %751, label %754
751: ; preds = %740
%752 = add nsw i32 %2, -4
%753 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %752)
br label %1593
754: ; preds = %740
%755 = getelementptr inbounds i8, i8* %1, i64 7
%756 = load i8, i8* %755
%757 = zext i8 %756 to i32
%758 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.33, i64 0, i64 0), i32 %757)
%759 = icmp eq i8 %756, 0
br i1 %759, label %1593, label %760
760: ; preds = %754
%761 = zext i8 %756 to i64
br label %762
762: ; preds = %760, %762
%763 = phi i64 [ 0, %760 ], [ %769, %762 ]
%764 = add nuw nsw i64 %763, 8
%765 = getelementptr inbounds i8, i8* %1, i64 %764
%766 = load i8, i8* %765
%767 = zext i8 %766 to i32
%768 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.34, i64 0, i64 0), i32 %767)
%769 = add nuw nsw i64 %763, 1
%770 = icmp eq i64 %769, %761
br i1 %770, label %1593, label %762
771: ; preds = %3
%772 = getelementptr inbounds i8, i8* %1, i64 2
%773 = load i8, i8* %772
%774 = zext i8 %773 to i32
%775 = lshr i32 %774, 2
%776 = and i32 %775, 15
%777 = lshr i32 %774, 1
%778 = and i32 %777, 1
%779 = and i32 %774, 1
%780 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %776, i32 %778, i32 %779, i32 52)
%781 = icmp slt i32 %2, 8
br i1 %781, label %782, label %785
782: ; preds = %771
%783 = add nsw i32 %2, -4
%784 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %783)
br label %1593
785: ; preds = %771
%786 = getelementptr inbounds i8, i8* %1, i64 4
%787 = load i8, i8* %786
%788 = and i8 %787, 1
%789 = zext i8 %788 to i32
%790 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.49, i64 0, i64 0), i32 %789)
%791 = getelementptr inbounds i8, i8* %1, i64 7
%792 = load i8, i8* %791
%793 = zext i8 %792 to i32
%794 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.50, i64 0, i64 0), i32 %793)
br label %1593
795: ; preds = %3
%796 = getelementptr inbounds i8, i8* %1, i64 2
%797 = load i8, i8* %796
%798 = zext i8 %797 to i32
%799 = lshr i32 %798, 2
%800 = and i32 %799, 15
%801 = lshr i32 %798, 1
%802 = and i32 %801, 1
%803 = and i32 %798, 1
%804 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %800, i32 %802, i32 %803, i32 55)
%805 = icmp slt i32 %2, 8
br i1 %805, label %806, label %809
806: ; preds = %795
%807 = add nsw i32 %2, -4
%808 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %807)
br label %1593
809: ; preds = %795
%810 = getelementptr inbounds i8, i8* %1, i64 5
%811 = load i8, i8* %810
%812 = zext i8 %811 to i32
%813 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.51, i64 0, i64 0), i32 %812)
br label %1593
814: ; preds = %3
%815 = getelementptr inbounds i8, i8* %1, i64 2
%816 = load i8, i8* %815
%817 = zext i8 %816 to i32
%818 = lshr i32 %817, 2
%819 = and i32 %818, 15
%820 = lshr i32 %817, 1
%821 = and i32 %820, 1
%822 = and i32 %817, 1
%823 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %819, i32 %821, i32 %822, i32 58)
%824 = icmp slt i32 %2, 8
br i1 %824, label %825, label %828
825: ; preds = %814
%826 = add nsw i32 %2, -4
%827 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %826)
br label %1593
828: ; preds = %814
%829 = getelementptr inbounds i8, i8* %1, i64 4
%830 = load i8, i8* %829
%831 = and i8 %830, 1
%832 = zext i8 %831 to i32
%833 = getelementptr inbounds i8, i8* %1, i64 5
%834 = load i8, i8* %833
%835 = zext i8 %834 to i32
%836 = lshr i32 %835, 1
%837 = and i32 %836, 1
%838 = and i32 %835, 1
%839 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.52, i64 0, i64 0), i32 %832, i32 %837, i32 %838)
br label %1593
840: ; preds = %3
%841 = getelementptr inbounds i8, i8* %1, i64 2
%842 = load i8, i8* %841
%843 = zext i8 %842 to i32
%844 = lshr i32 %843, 2
%845 = and i32 %844, 15
%846 = lshr i32 %843, 1
%847 = and i32 %846, 1
%848 = and i32 %843, 1
%849 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %845, i32 %847, i32 %848, i32 59)
%850 = icmp slt i32 %2, 8
br i1 %850, label %851, label %854
851: ; preds = %840
%852 = add nsw i32 %2, -4
%853 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %852)
br label %1593
854: ; preds = %840
%855 = getelementptr inbounds i8, i8* %1, i64 4
%856 = load i8, i8* %855
%857 = and i8 %856, 1
%858 = zext i8 %857 to i32
%859 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.53, i64 0, i64 0), i32 %858)
br label %1593
860: ; preds = %3
%861 = getelementptr inbounds i8, i8* %1, i64 2
%862 = load i8, i8* %861
%863 = zext i8 %862 to i32
%864 = lshr i32 %863, 2
%865 = and i32 %864, 15
%866 = lshr i32 %863, 1
%867 = and i32 %866, 1
%868 = and i32 %863, 1
%869 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %865, i32 %867, i32 %868, i32 64)
%870 = icmp slt i32 %2, 32
br i1 %870, label %871, label %874
871: ; preds = %860
%872 = add nsw i32 %2, -4
%873 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %872)
br label %1593
874: ; preds = %860
%875 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.88, i64 0, i64 0))
%876 = getelementptr inbounds i8, i8* %1, i64 8
%877 = load i8, i8* %876
%878 = zext i8 %877 to i32
%879 = shl nuw nsw i32 %878, 8
%880 = getelementptr inbounds i8, i8* %1, i64 9
%881 = load i8, i8* %880
%882 = zext i8 %881 to i32
%883 = or i32 %879, %882
%884 = getelementptr inbounds i8, i8* %1, i64 10
%885 = load i8, i8* %884
%886 = zext i8 %885 to i32
%887 = shl nuw nsw i32 %886, 8
%888 = getelementptr inbounds i8, i8* %1, i64 11
%889 = load i8, i8* %888
%890 = zext i8 %889 to i32
%891 = or i32 %887, %890
%892 = getelementptr inbounds i8, i8* %1, i64 12
%893 = load i8, i8* %892
%894 = zext i8 %893 to i32
%895 = shl nuw nsw i32 %894, 8
%896 = getelementptr inbounds i8, i8* %1, i64 13
%897 = load i8, i8* %896
%898 = zext i8 %897 to i32
%899 = or i32 %895, %898
%900 = getelementptr inbounds i8, i8* %1, i64 14
%901 = load i8, i8* %900
%902 = zext i8 %901 to i32
%903 = shl nuw nsw i32 %902, 8
%904 = getelementptr inbounds i8, i8* %1, i64 15
%905 = load i8, i8* %904
%906 = zext i8 %905 to i32
%907 = or i32 %903, %906
%908 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %883, i32 %891, i32 %899, i32 %907)
%909 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.89, i64 0, i64 0))
%910 = getelementptr inbounds i8, i8* %1, i64 16
%911 = load i8, i8* %910
%912 = zext i8 %911 to i32
%913 = shl nuw nsw i32 %912, 8
%914 = getelementptr inbounds i8, i8* %1, i64 17
%915 = load i8, i8* %914
%916 = zext i8 %915 to i32
%917 = or i32 %913, %916
%918 = getelementptr inbounds i8, i8* %1, i64 18
%919 = load i8, i8* %918
%920 = zext i8 %919 to i32
%921 = shl nuw nsw i32 %920, 8
%922 = getelementptr inbounds i8, i8* %1, i64 19
%923 = load i8, i8* %922
%924 = zext i8 %923 to i32
%925 = or i32 %921, %924
%926 = getelementptr inbounds i8, i8* %1, i64 20
%927 = load i8, i8* %926
%928 = zext i8 %927 to i32
%929 = shl nuw nsw i32 %928, 8
%930 = getelementptr inbounds i8, i8* %1, i64 21
%931 = load i8, i8* %930
%932 = zext i8 %931 to i32
%933 = or i32 %929, %932
%934 = getelementptr inbounds i8, i8* %1, i64 22
%935 = load i8, i8* %934
%936 = zext i8 %935 to i32
%937 = shl nuw nsw i32 %936, 8
%938 = getelementptr inbounds i8, i8* %1, i64 23
%939 = load i8, i8* %938
%940 = zext i8 %939 to i32
%941 = or i32 %937, %940
%942 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %917, i32 %925, i32 %933, i32 %941)
%943 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.90, i64 0, i64 0))
%944 = getelementptr inbounds i8, i8* %1, i64 24
%945 = load i8, i8* %944
%946 = zext i8 %945 to i32
%947 = shl nuw nsw i32 %946, 8
%948 = getelementptr inbounds i8, i8* %1, i64 25
%949 = load i8, i8* %948
%950 = zext i8 %949 to i32
%951 = or i32 %947, %950
%952 = getelementptr inbounds i8, i8* %1, i64 26
%953 = load i8, i8* %952
%954 = zext i8 %953 to i32
%955 = shl nuw nsw i32 %954, 8
%956 = getelementptr inbounds i8, i8* %1, i64 27
%957 = load i8, i8* %956
%958 = zext i8 %957 to i32
%959 = or i32 %955, %958
%960 = getelementptr inbounds i8, i8* %1, i64 28
%961 = load i8, i8* %960
%962 = zext i8 %961 to i32
%963 = shl nuw nsw i32 %962, 8
%964 = getelementptr inbounds i8, i8* %1, i64 29
%965 = load i8, i8* %964
%966 = zext i8 %965 to i32
%967 = or i32 %963, %966
%968 = getelementptr inbounds i8, i8* %1, i64 30
%969 = load i8, i8* %968
%970 = zext i8 %969 to i32
%971 = shl nuw nsw i32 %970, 8
%972 = getelementptr inbounds i8, i8* %1, i64 31
%973 = load i8, i8* %972
%974 = zext i8 %973 to i32
%975 = or i32 %971, %974
%976 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %951, i32 %959, i32 %967, i32 %975)
br label %1593
977: ; preds = %3
%978 = getelementptr inbounds i8, i8* %1, i64 2
%979 = load i8, i8* %978
%980 = zext i8 %979 to i32
%981 = lshr i32 %980, 2
%982 = and i32 %981, 15
%983 = lshr i32 %980, 1
%984 = and i32 %983, 1
%985 = and i32 %980, 1
%986 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %982, i32 %984, i32 %985, i32 65)
%987 = icmp slt i32 %2, 32
br i1 %987, label %988, label %991
988: ; preds = %977
%989 = add nsw i32 %2, -4
%990 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %989)
br label %1593
991: ; preds = %977
%992 = getelementptr inbounds i8, i8* %1, i64 4
%993 = load i8, i8* %992
%994 = and i8 %993, 1
%995 = zext i8 %994 to i32
%996 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.58, i64 0, i64 0), i32 %995)
%997 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.85, i64 0, i64 0))
%998 = getelementptr inbounds i8, i8* %1, i64 8
%999 = load i8, i8* %998
%1000 = zext i8 %999 to i32
%1001 = shl nuw nsw i32 %1000, 8
%1002 = getelementptr inbounds i8, i8* %1, i64 9
%1003 = load i8, i8* %1002
%1004 = zext i8 %1003 to i32
%1005 = or i32 %1001, %1004
%1006 = getelementptr inbounds i8, i8* %1, i64 10
%1007 = load i8, i8* %1006
%1008 = zext i8 %1007 to i32
%1009 = shl nuw nsw i32 %1008, 8
%1010 = getelementptr inbounds i8, i8* %1, i64 11
%1011 = load i8, i8* %1010
%1012 = zext i8 %1011 to i32
%1013 = or i32 %1009, %1012
%1014 = getelementptr inbounds i8, i8* %1, i64 12
%1015 = load i8, i8* %1014
%1016 = zext i8 %1015 to i32
%1017 = shl nuw nsw i32 %1016, 8
%1018 = getelementptr inbounds i8, i8* %1, i64 13
%1019 = load i8, i8* %1018
%1020 = zext i8 %1019 to i32
%1021 = or i32 %1017, %1020
%1022 = getelementptr inbounds i8, i8* %1, i64 14
%1023 = load i8, i8* %1022
%1024 = zext i8 %1023 to i32
%1025 = shl nuw nsw i32 %1024, 8
%1026 = getelementptr inbounds i8, i8* %1, i64 15
%1027 = load i8, i8* %1026
%1028 = zext i8 %1027 to i32
%1029 = or i32 %1025, %1028
%1030 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %1005, i32 %1013, i32 %1021, i32 %1029)
%1031 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.86, i64 0, i64 0))
%1032 = getelementptr inbounds i8, i8* %1, i64 16
%1033 = load i8, i8* %1032
%1034 = zext i8 %1033 to i32
%1035 = shl nuw nsw i32 %1034, 8
%1036 = getelementptr inbounds i8, i8* %1, i64 17
%1037 = load i8, i8* %1036
%1038 = zext i8 %1037 to i32
%1039 = or i32 %1035, %1038
%1040 = getelementptr inbounds i8, i8* %1, i64 18
%1041 = load i8, i8* %1040
%1042 = zext i8 %1041 to i32
%1043 = shl nuw nsw i32 %1042, 8
%1044 = getelementptr inbounds i8, i8* %1, i64 19
%1045 = load i8, i8* %1044
%1046 = zext i8 %1045 to i32
%1047 = or i32 %1043, %1046
%1048 = getelementptr inbounds i8, i8* %1, i64 20
%1049 = load i8, i8* %1048
%1050 = zext i8 %1049 to i32
%1051 = shl nuw nsw i32 %1050, 8
%1052 = getelementptr inbounds i8, i8* %1, i64 21
%1053 = load i8, i8* %1052
%1054 = zext i8 %1053 to i32
%1055 = or i32 %1051, %1054
%1056 = getelementptr inbounds i8, i8* %1, i64 22
%1057 = load i8, i8* %1056
%1058 = zext i8 %1057 to i32
%1059 = shl nuw nsw i32 %1058, 8
%1060 = getelementptr inbounds i8, i8* %1, i64 23
%1061 = load i8, i8* %1060
%1062 = zext i8 %1061 to i32
%1063 = or i32 %1059, %1062
%1064 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %1039, i32 %1047, i32 %1055, i32 %1063)
%1065 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.87, i64 0, i64 0))
%1066 = getelementptr inbounds i8, i8* %1, i64 24
%1067 = load i8, i8* %1066
%1068 = zext i8 %1067 to i32
%1069 = shl nuw nsw i32 %1068, 8
%1070 = getelementptr inbounds i8, i8* %1, i64 25
%1071 = load i8, i8* %1070
%1072 = zext i8 %1071 to i32
%1073 = or i32 %1069, %1072
%1074 = getelementptr inbounds i8, i8* %1, i64 26
%1075 = load i8, i8* %1074
%1076 = zext i8 %1075 to i32
%1077 = shl nuw nsw i32 %1076, 8
%1078 = getelementptr inbounds i8, i8* %1, i64 27
%1079 = load i8, i8* %1078
%1080 = zext i8 %1079 to i32
%1081 = or i32 %1077, %1080
%1082 = getelementptr inbounds i8, i8* %1, i64 28
%1083 = load i8, i8* %1082
%1084 = zext i8 %1083 to i32
%1085 = shl nuw nsw i32 %1084, 8
%1086 = getelementptr inbounds i8, i8* %1, i64 29
%1087 = load i8, i8* %1086
%1088 = zext i8 %1087 to i32
%1089 = or i32 %1085, %1088
%1090 = getelementptr inbounds i8, i8* %1, i64 30
%1091 = load i8, i8* %1090
%1092 = zext i8 %1091 to i32
%1093 = shl nuw nsw i32 %1092, 8
%1094 = getelementptr inbounds i8, i8* %1, i64 31
%1095 = load i8, i8* %1094
%1096 = zext i8 %1095 to i32
%1097 = or i32 %1093, %1096
%1098 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.55, i64 0, i64 0), i32 %1073, i32 %1081, i32 %1089, i32 %1097)
br label %1593
1099: ; preds = %3
%1100 = getelementptr inbounds i8, i8* %1, i64 2
%1101 = load i8, i8* %1100
%1102 = zext i8 %1101 to i32
%1103 = lshr i32 %1102, 2
%1104 = and i32 %1103, 15
%1105 = lshr i32 %1102, 1
%1106 = and i32 %1105, 1
%1107 = and i32 %1102, 1
%1108 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1104, i32 %1106, i32 %1107, i32 80)
%1109 = icmp slt i32 %2, 8
br i1 %1109, label %1110, label %1113
1110: ; preds = %1099
%1111 = add nsw i32 %2, -4
%1112 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1111)
br label %1593
1113: ; preds = %1099
%1114 = getelementptr inbounds i8, i8* %1, i64 4
%1115 = load i8, i8* %1114
%1116 = and i8 %1115, 1
%1117 = zext i8 %1116 to i32
%1118 = getelementptr inbounds i8, i8* %1, i64 6
%1119 = load i8, i8* %1118
%1120 = and i8 %1119, 1
%1121 = zext i8 %1120 to i32
%1122 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.62, i64 0, i64 0), i32 %1117, i32 %1121)
br label %1593
1123: ; preds = %3
%1124 = getelementptr inbounds i8, i8* %1, i64 2
%1125 = load i8, i8* %1124
%1126 = zext i8 %1125 to i32
%1127 = lshr i32 %1126, 2
%1128 = and i32 %1127, 15
%1129 = lshr i32 %1126, 1
%1130 = and i32 %1129, 1
%1131 = and i32 %1126, 1
%1132 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1128, i32 %1130, i32 %1131, i32 81)
%1133 = icmp slt i32 %2, 8
br i1 %1133, label %1134, label %1137
1134: ; preds = %1123
%1135 = add nsw i32 %2, -4
%1136 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1135)
br label %1593
1137: ; preds = %1123
%1138 = getelementptr inbounds i8, i8* %1, i64 4
%1139 = load i8, i8* %1138
%1140 = and i8 %1139, 1
%1141 = zext i8 %1140 to i32
%1142 = getelementptr inbounds i8, i8* %1, i64 6
%1143 = load i8, i8* %1142
%1144 = and i8 %1143, 1
%1145 = zext i8 %1144 to i32
%1146 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.62, i64 0, i64 0), i32 %1141, i32 %1145)
br label %1593
1147: ; preds = %3
%1148 = getelementptr inbounds i8, i8* %1, i64 2
%1149 = load i8, i8* %1148
%1150 = zext i8 %1149 to i32
%1151 = lshr i32 %1150, 2
%1152 = and i32 %1151, 15
%1153 = lshr i32 %1150, 1
%1154 = and i32 %1153, 1
%1155 = and i32 %1150, 1
%1156 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1152, i32 %1154, i32 %1155, i32 82)
%1157 = icmp slt i32 %2, 8
br i1 %1157, label %1158, label %1161
1158: ; preds = %1147
%1159 = add nsw i32 %2, -4
%1160 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1159)
br label %1593
1161: ; preds = %1147
%1162 = getelementptr inbounds i8, i8* %1, i64 4
%1163 = load i8, i8* %1162
%1164 = and i8 %1163, 1
%1165 = zext i8 %1164 to i32
%1166 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.63, i64 0, i64 0), i32 %1165)
br label %1593
1167: ; preds = %3
%1168 = getelementptr inbounds i8, i8* %1, i64 2
%1169 = load i8, i8* %1168
%1170 = zext i8 %1169 to i32
%1171 = lshr i32 %1170, 2
%1172 = and i32 %1171, 15
%1173 = lshr i32 %1170, 1
%1174 = and i32 %1173, 1
%1175 = and i32 %1170, 1
%1176 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1172, i32 %1174, i32 %1175, i32 128)
%1177 = icmp slt i32 %2, 8
br i1 %1177, label %1178, label %1181
1178: ; preds = %1167
%1179 = add nsw i32 %2, -4
%1180 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1179)
br label %1593
1181: ; preds = %1167
%1182 = getelementptr inbounds i8, i8* %1, i64 4
%1183 = load i8, i8* %1182
%1184 = and i8 %1183, 1
%1185 = zext i8 %1184 to i32
%1186 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.64, i64 0, i64 0), i32 %1185)
br label %1593
1187: ; preds = %3
%1188 = getelementptr inbounds i8, i8* %1, i64 2
%1189 = load i8, i8* %1188
%1190 = zext i8 %1189 to i32
%1191 = lshr i32 %1190, 2
%1192 = and i32 %1191, 15
%1193 = lshr i32 %1190, 1
%1194 = and i32 %1193, 1
%1195 = and i32 %1190, 1
%1196 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1192, i32 %1194, i32 %1195, i32 257)
%1197 = icmp slt i32 %2, 8
br i1 %1197, label %1198, label %1201
1198: ; preds = %1187
%1199 = add nsw i32 %2, -4
%1200 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1199)
br label %1593
1201: ; preds = %1187
%1202 = getelementptr inbounds i8, i8* %1, i64 4
%1203 = load i8, i8* %1202
%1204 = and i8 %1203, 1
%1205 = zext i8 %1204 to i32
%1206 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.65, i64 0, i64 0), i32 %1205)
br label %1593
1207: ; preds = %3
%1208 = getelementptr inbounds i8, i8* %1, i64 2
%1209 = load i8, i8* %1208
%1210 = zext i8 %1209 to i32
%1211 = lshr i32 %1210, 2
%1212 = and i32 %1211, 15
%1213 = lshr i32 %1210, 1
%1214 = and i32 %1213, 1
%1215 = and i32 %1210, 1
%1216 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1212, i32 %1214, i32 %1215, i32 258)
%1217 = icmp slt i32 %2, 8
br i1 %1217, label %1218, label %1221
1218: ; preds = %1207
%1219 = add nsw i32 %2, -4
%1220 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1219)
br label %1593
1221: ; preds = %1207
%1222 = getelementptr inbounds i8, i8* %1, i64 4
%1223 = load i8, i8* %1222
%1224 = zext i8 %1223 to i32
%1225 = lshr i32 %1224, 4
%1226 = and i32 %1225, 1
%1227 = lshr i32 %1224, 2
%1228 = and i32 %1227, 1
%1229 = getelementptr inbounds i8, i8* %1, i64 7
%1230 = load i8, i8* %1229
%1231 = and i8 %1230, 31
%1232 = zext i8 %1231 to i32
%1233 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.66, i64 0, i64 0), i32 %1226, i32 %1228, i32 %1232)
br label %1593
1234: ; preds = %3
%1235 = getelementptr inbounds i8, i8* %1, i64 2
%1236 = load i8, i8* %1235
%1237 = zext i8 %1236 to i32
%1238 = lshr i32 %1237, 2
%1239 = and i32 %1238, 15
%1240 = lshr i32 %1237, 1
%1241 = and i32 %1240, 1
%1242 = and i32 %1237, 1
%1243 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1239, i32 %1241, i32 %1242, i32 259)
%1244 = icmp slt i32 %2, 8
br i1 %1244, label %1245, label %1248
1245: ; preds = %1234
%1246 = add nsw i32 %2, -4
%1247 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1246)
br label %1593
1248: ; preds = %1234
%1249 = getelementptr inbounds i8, i8* %1, i64 4
%1250 = load i8, i8* %1249
%1251 = zext i8 %1250 to i32
%1252 = lshr i32 %1251, 2
%1253 = and i32 %1252, 1
%1254 = lshr i32 %1251, 1
%1255 = and i32 %1254, 1
%1256 = and i32 %1251, 1
%1257 = getelementptr inbounds i8, i8* %1, i64 6
%1258 = load i8, i8* %1257
%1259 = zext i8 %1258 to i32
%1260 = shl nuw nsw i32 %1259, 8
%1261 = getelementptr inbounds i8, i8* %1, i64 7
%1262 = load i8, i8* %1261
%1263 = zext i8 %1262 to i32
%1264 = or i32 %1260, %1263
%1265 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @.str.67, i64 0, i64 0), i32 %1253, i32 %1255, i32 %1256, i32 %1264)
br label %1593
1266: ; preds = %3
%1267 = getelementptr inbounds i8, i8* %1, i64 2
%1268 = load i8, i8* %1267
%1269 = zext i8 %1268 to i32
%1270 = lshr i32 %1269, 2
%1271 = and i32 %1270, 15
%1272 = lshr i32 %1269, 1
%1273 = and i32 %1272, 1
%1274 = and i32 %1269, 1
%1275 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1271, i32 %1273, i32 %1274, i32 260)
%1276 = icmp slt i32 %2, 4
br i1 %1276, label %1277, label %1280
1277: ; preds = %1266
%1278 = add nsw i32 %2, -4
%1279 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1278)
br label %1593
1280: ; preds = %1266
%1281 = icmp eq i32 %2, 4
br i1 %1281, label %1593, label %1282
1282: ; preds = %1280
%1283 = getelementptr inbounds i8, i8* %1, i64 4
%1284 = load i8, i8* %1283
%1285 = and i8 %1284, 1
%1286 = zext i8 %1285 to i32
%1287 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.68, i64 0, i64 0), i32 %1286)
br label %1593
1288: ; preds = %3
%1289 = getelementptr inbounds i8, i8* %1, i64 2
%1290 = load i8, i8* %1289
%1291 = zext i8 %1290 to i32
%1292 = lshr i32 %1291, 2
%1293 = and i32 %1292, 15
%1294 = lshr i32 %1291, 1
%1295 = and i32 %1294, 1
%1296 = and i32 %1291, 1
%1297 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1293, i32 %1295, i32 %1296, i32 261)
%1298 = icmp sgt i32 %2, 7
br i1 %1298, label %1299, label %1593
1299: ; preds = %1288
%1300 = getelementptr inbounds i8, i8* %1, i64 4
%1301 = load i8, i8* %1300
%1302 = and i8 %1301, 1
%1303 = zext i8 %1302 to i32
%1304 = getelementptr inbounds i8, i8* %1, i64 6
%1305 = load i8, i8* %1304
%1306 = zext i8 %1305 to i32
%1307 = shl nuw nsw i32 %1306, 8
%1308 = getelementptr inbounds i8, i8* %1, i64 7
%1309 = load i8, i8* %1308
%1310 = zext i8 %1309 to i32
%1311 = or i32 %1307, %1310
%1312 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.69, i64 0, i64 0), i32 %1303, i32 %1311)
br label %1593
1313: ; preds = %3
%1314 = getelementptr inbounds i8, i8* %1, i64 2
%1315 = load i8, i8* %1314
%1316 = zext i8 %1315 to i32
%1317 = lshr i32 %1316, 2
%1318 = and i32 %1317, 15
%1319 = lshr i32 %1316, 1
%1320 = and i32 %1319, 1
%1321 = and i32 %1316, 1
%1322 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1318, i32 %1320, i32 %1321, i32 262)
%1323 = icmp slt i32 %2, 8
br i1 %1323, label %1324, label %1327
1324: ; preds = %1313
%1325 = add nsw i32 %2, -4
%1326 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1325)
br label %1593
1327: ; preds = %1313
%1328 = getelementptr inbounds i8, i8* %1, i64 7
%1329 = load i8, i8* %1328
%1330 = zext i8 %1329 to i32
%1331 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.70, i64 0, i64 0), i32 %1330)
br label %1593
1332: ; preds = %3
%1333 = getelementptr inbounds i8, i8* %1, i64 2
%1334 = load i8, i8* %1333
%1335 = zext i8 %1334 to i32
%1336 = lshr i32 %1335, 2
%1337 = and i32 %1336, 15
%1338 = lshr i32 %1335, 1
%1339 = and i32 %1338, 1
%1340 = and i32 %1335, 1
%1341 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1337, i32 %1339, i32 %1340, i32 263)
%1342 = icmp slt i32 %2, 8
br i1 %1342, label %1343, label %1346
1343: ; preds = %1332
%1344 = add nsw i32 %2, -4
%1345 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1344)
br label %1593
1346: ; preds = %1332
%1347 = getelementptr inbounds i8, i8* %1, i64 4
%1348 = load i8, i8* %1347
%1349 = zext i8 %1348 to i32
%1350 = lshr i32 %1349, 4
%1351 = and i32 %1350, 1
%1352 = lshr i32 %1349, 3
%1353 = and i32 %1352, 1
%1354 = lshr i32 %1349, 2
%1355 = and i32 %1354, 1
%1356 = lshr i32 %1349, 1
%1357 = and i32 %1356, 1
%1358 = and i32 %1349, 1
%1359 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.71, i64 0, i64 0), i32 %1351, i32 %1353, i32 %1355, i32 %1357, i32 %1358)
br label %1593
1360: ; preds = %3
%1361 = getelementptr inbounds i8, i8* %1, i64 2
%1362 = load i8, i8* %1361
%1363 = zext i8 %1362 to i32
%1364 = lshr i32 %1363, 2
%1365 = and i32 %1364, 15
%1366 = lshr i32 %1363, 1
%1367 = and i32 %1366, 1
%1368 = and i32 %1363, 1
%1369 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1365, i32 %1367, i32 %1368, i32 264)
%1370 = icmp slt i32 %2, 131
%1371 = select i1 %1370, i32 %2, i32 131
%1372 = add nsw i32 %1371, -4
%1373 = getelementptr inbounds i8, i8* %1, i64 4
%1374 = sext i32 %1372 to i64
%1375 = call i8* @strncpy(i8* %5, i8* %1373, i64 %1374)
%1376 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 %1374
store i8 0, i8* %1376
%1377 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.72, i64 0, i64 0), i8* %5)
br label %1593
1378: ; preds = %3
%1379 = getelementptr inbounds i8, i8* %1, i64 2
%1380 = load i8, i8* %1379
%1381 = zext i8 %1380 to i32
%1382 = lshr i32 %1381, 2
%1383 = and i32 %1382, 15
%1384 = lshr i32 %1381, 1
%1385 = and i32 %1384, 1
%1386 = and i32 %1381, 1
%1387 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1383, i32 %1385, i32 %1386, i32 266)
%1388 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.84, i64 0, i64 0))
%1389 = icmp sgt i32 %2, 4
br i1 %1389, label %1390, label %1593
1390: ; preds = %1378, %1390
%1391 = phi i64 [ %1414, %1390 ], [ 4, %1378 ]
%1392 = getelementptr inbounds i8, i8* %1, i64 %1391
%1393 = load i8, i8* %1392
%1394 = zext i8 %1393 to i32
%1395 = shl nuw i32 %1394, 24
%1396 = or i64 %1391, 1
%1397 = getelementptr inbounds i8, i8* %1, i64 %1396
%1398 = load i8, i8* %1397
%1399 = zext i8 %1398 to i32
%1400 = shl nuw nsw i32 %1399, 16
%1401 = or i32 %1400, %1395
%1402 = or i64 %1391, 2
%1403 = getelementptr inbounds i8, i8* %1, i64 %1402
%1404 = load i8, i8* %1403
%1405 = zext i8 %1404 to i32
%1406 = shl nuw nsw i32 %1405, 8
%1407 = or i32 %1401, %1406
%1408 = or i64 %1391, 3
%1409 = getelementptr inbounds i8, i8* %1, i64 %1408
%1410 = load i8, i8* %1409
%1411 = zext i8 %1410 to i32
%1412 = or i32 %1407, %1411
%1413 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.74, i64 0, i64 0), i32 %1412)
%1414 = add nuw i64 %1391, 4
%1415 = trunc i64 %1414 to i32
%1416 = icmp slt i32 %1415, %2
br i1 %1416, label %1390, label %1593
1417: ; preds = %3
%1418 = getelementptr inbounds i8, i8* %1, i64 2
%1419 = load i8, i8* %1418
%1420 = zext i8 %1419 to i32
%1421 = lshr i32 %1420, 2
%1422 = and i32 %1421, 15
%1423 = lshr i32 %1420, 1
%1424 = and i32 %1423, 1
%1425 = and i32 %1420, 1
%1426 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1422, i32 %1424, i32 %1425, i32 267)
%1427 = icmp slt i32 %2, 8
br i1 %1427, label %1428, label %1431
1428: ; preds = %1417
%1429 = add nsw i32 %2, -4
%1430 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1429)
br label %1593
1431: ; preds = %1417
%1432 = getelementptr inbounds i8, i8* %1, i64 7
%1433 = load i8, i8* %1432
%1434 = zext i8 %1433 to i32
%1435 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.75, i64 0, i64 0), i32 %1434)
br label %1593
1436: ; preds = %3
%1437 = getelementptr inbounds i8, i8* %1, i64 2
%1438 = load i8, i8* %1437
%1439 = zext i8 %1438 to i32
%1440 = lshr i32 %1439, 2
%1441 = and i32 %1440, 15
%1442 = lshr i32 %1439, 1
%1443 = and i32 %1442, 1
%1444 = and i32 %1439, 1
%1445 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1441, i32 %1443, i32 %1444, i32 268)
%1446 = icmp slt i32 %2, 20
br i1 %1446, label %1447, label %1450
1447: ; preds = %1436
%1448 = add nsw i32 %2, -4
%1449 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1448)
br label %1593
1450: ; preds = %1436
%1451 = getelementptr inbounds i8, i8* %1, i64 4
%1452 = getelementptr inbounds i8, i8* %1, i64 6
%1453 = getelementptr inbounds i8, i8* %1, i64 8
%1454 = getelementptr inbounds i8, i8* %1, i64 10
%1455 = getelementptr inbounds i8, i8* %1, i64 12
%1456 = getelementptr inbounds i8, i8* %1, i64 14
%1457 = getelementptr inbounds i8, i8* %1, i64 16
%1458 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.76, i64 0, i64 0), i8* %1451, i8* %1452, i8* %1453, i8* %1454, i8* %1455, i8* %1456, i8* %1457)
br label %1593
1459: ; preds = %3
%1460 = getelementptr inbounds i8, i8* %1, i64 2
%1461 = load i8, i8* %1460
%1462 = zext i8 %1461 to i32
%1463 = lshr i32 %1462, 2
%1464 = and i32 %1463, 15
%1465 = lshr i32 %1462, 1
%1466 = and i32 %1465, 1
%1467 = and i32 %1462, 1
%1468 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1464, i32 %1466, i32 %1467, i32 269)
%1469 = icmp slt i32 %2, 8
br i1 %1469, label %1470, label %1473
1470: ; preds = %1459
%1471 = add nsw i32 %2, -4
%1472 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1471)
br label %1593
1473: ; preds = %1459
%1474 = getelementptr inbounds i8, i8* %1, i64 4
%1475 = load i8, i8* %1474
%1476 = and i8 %1475, 1
%1477 = zext i8 %1476 to i32
%1478 = getelementptr inbounds i8, i8* %1, i64 5
%1479 = load i8, i8* %1478
%1480 = zext i8 %1479 to i32
%1481 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.77, i64 0, i64 0), i32 %1477, i32 %1480)
%1482 = getelementptr inbounds i8, i8* %1, i64 6
%1483 = load i8, i8* %1482
%1484 = and i8 %1483, 15
%1485 = zext i8 %1484 to i32
%1486 = getelementptr inbounds i8, i8* %1, i64 7
%1487 = load i8, i8* %1486
%1488 = zext i8 %1487 to i32
%1489 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.78, i64 0, i64 0), i32 %1485, i32 %1488)
br label %1593
1490: ; preds = %3
%1491 = getelementptr inbounds i8, i8* %1, i64 2
%1492 = load i8, i8* %1491
%1493 = zext i8 %1492 to i32
%1494 = lshr i32 %1493, 2
%1495 = and i32 %1494, 15
%1496 = lshr i32 %1493, 1
%1497 = and i32 %1496, 1
%1498 = and i32 %1493, 1
%1499 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1495, i32 %1497, i32 %1498, i32 270)
%1500 = icmp slt i32 %2, 8
br i1 %1500, label %1501, label %1504
1501: ; preds = %1490
%1502 = add nsw i32 %2, -4
%1503 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1502)
br label %1593
1504: ; preds = %1490
%1505 = getelementptr inbounds i8, i8* %1, i64 4
%1506 = load i8, i8* %1505
%1507 = zext i8 %1506 to i32
%1508 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.79, i64 0, i64 0), i32 %1507)
br label %1593
1509: ; preds = %3
%1510 = getelementptr inbounds i8, i8* %1, i64 2
%1511 = load i8, i8* %1510
%1512 = zext i8 %1511 to i32
%1513 = lshr i32 %1512, 2
%1514 = and i32 %1513, 15
%1515 = lshr i32 %1512, 1
%1516 = and i32 %1515, 1
%1517 = and i32 %1512, 1
%1518 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1514, i32 %1516, i32 %1517, i32 288)
%1519 = icmp slt i32 %2, 8
br i1 %1519, label %1520, label %1523
1520: ; preds = %1509
%1521 = add nsw i32 %2, -4
%1522 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1521)
br label %1593
1523: ; preds = %1509
%1524 = getelementptr inbounds i8, i8* %1, i64 5
%1525 = load i8, i8* %1524
%1526 = zext i8 %1525 to i32
%1527 = lshr i32 %1526, 4
%1528 = and i32 %1526, 15
%1529 = getelementptr inbounds i8, i8* %1, i64 6
%1530 = load i8, i8* %1529
%1531 = and i8 %1530, 3
%1532 = zext i8 %1531 to i32
%1533 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.80, i64 0, i64 0), i32 %1527, i32 %1528, i32 %1532)
br label %1593
1534: ; preds = %3
%1535 = getelementptr inbounds i8, i8* %1, i64 2
%1536 = load i8, i8* %1535
%1537 = zext i8 %1536 to i32
%1538 = lshr i32 %1537, 2
%1539 = and i32 %1538, 15
%1540 = lshr i32 %1537, 1
%1541 = and i32 %1540, 1
%1542 = and i32 %1537, 1
%1543 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.1, i64 0, i64 0), i32 %1539, i32 %1541, i32 %1542, i32 322)
%1544 = icmp slt i32 %2, 8
br i1 %1544, label %1545, label %1548
1545: ; preds = %1534
%1546 = add nsw i32 %2, -4
%1547 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0), i32 %1546)
br label %1593
1548: ; preds = %1534
%1549 = getelementptr inbounds i8, i8* %1, i64 4
%1550 = load i8, i8* %1549
%1551 = zext i8 %1550 to i32
%1552 = lshr i32 %1551, 7
%1553 = lshr i32 %1551, 6
%1554 = and i32 %1553, 1
%1555 = and i32 %1551, 1
%1556 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.81, i64 0, i64 0), i32 %1552, i32 %1554, i32 %1555)
%1557 = getelementptr inbounds i8, i8* %1, i64 5
%1558 = load i8, i8* %1557
%1559 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str, i64 0, i64 0))
%1560 = icmp eq i8 %1558, 0
br i1 %1560, label %1593, label %1561
1561: ; preds = %1548
%1562 = zext i8 %1558 to i32
%1563 = zext i32 %2 to i64
br label %1564
1564: ; preds = %1561, %1564
%1565 = phi i64 [ 6, %1561 ], [ %1578, %1564 ]
%1566 = phi i32 [ %1562, %1561 ], [ %1577, %1564 ]
%1567 = getelementptr inbounds i8, i8* %1, i64 %1565
%1568 = load i8, i8* %1567
%1569 = zext i8 %1568 to i32
%1570 = shl nuw nsw i32 %1569, 8
%1571 = or i64 %1565, 1
%1572 = getelementptr inbounds i8, i8* %1, i64 %1571
%1573 = load i8, i8* %1572
%1574 = zext i8 %1573 to i32
%1575 = or i32 %1570, %1574
%1576 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.34, i64 0, i64 0), i32 %1575)
%1577 = add nsw i32 %1566, -1
%1578 = add nuw nsw i64 %1565, 2
%1579 = icmp ugt i32 %1566, 1
%1580 = icmp ult i64 %1578, %1563
%1581 = select i1 %1579, i1 %1580, i1 false
br i1 %1581, label %1564, label %1593
1582: ; preds = %3
%1583 = getelementptr inbounds i8, i8* %1, i64 2
%1584 = load i8, i8* %1583
%1585 = zext i8 %1584 to i32
%1586 = lshr i32 %1585, 2
%1587 = and i32 %1586, 15
%1588 = lshr i32 %1585, 1
%1589 = and i32 %1588, 1
%1590 = and i32 %1585, 1
%1591 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.83, i64 0, i64 0), i32 %0, i32 %1587, i32 %1589, i32 %1590)
%1592 = tail call i32 (i8*, i32, i32, ...) bitcast (i32 (...)* @dStrHex to i32 (i8*, i32, i32, ...)*)(i8* %1, i32 %2, i32 1)
br label %1593
1593: ; preds = %1564, %1390, %762, %393, %18, %1548, %1378, %754, %368, %6, %402, %1288, %1299, %1280, %1282, %499, %510, %436, %447, %413, %430, %267, %278, %87, %95, %1582, %1545, %1523, %1520, %1504, %1501, %1473, %1470, %1450, %1447, %1431, %1428, %1360, %1346, %1343, %1327, %1324, %1277, %1248, %1245, %1221, %1218, %1201, %1198, %1181, %1178, %1161, %1158, %1137, %1134, %1113, %1110, %991, %988, %874, %871, %854, %851, %828, %825, %809, %806, %785, %782, %751, %727, %724, %678, %675, %637, %634, %611, %608, %591, %588, %565, %562, %534, %531, %467, %464, %365, %304, %301, %258, %255, %234, %202, %199, %176, %173, %149, %130, %111, %108, %50
ret void
}