void print_edid(int port) {
  int i;
  unsigned u, u1, u2, tag, mi_cnt = 0, res_cnt = 0;
  unsigned char edid[0x80];
  unsigned hblank, hsync_ofs, hsync, vblank, vsync_ofs, vsync;
  char *s;
  struct {
    unsigned lcd : 1;
    unsigned vendor_id, product_id;
    unsigned width_mm, height_mm;
    unsigned year;
    unsigned min_vsync, max_vsync, min_hsync, max_hsync;
    unsigned hblank, hsync_ofs, hsync, vblank, vsync_ofs, vsync;
    char vendor_name[128], product_name[128], serial[128];
  } m = {};
  struct {
    unsigned width, height, width_mm, height_mm, clock;
    unsigned hdisp, hsyncstart, hsyncend, htotal, hflag;
    unsigned vdisp, vsyncstart, vsyncend, vtotal, vflag;
  } mi_list[4] = {}, *mi;
  struct {
    unsigned width, height, vfreq, il;
  } res[24] = {};
  u = probe_ddc(port, edid);
  if (!chk_edid_info(edid)) {
    printf("Port %u: no monitor info [err 0x%04x]\n\n", port, u);
    return;
  }
  if (edid[0x14] & 0x80)
    m.lcd = 1;
  m.vendor_id = (edid[8] << 8) + edid[9];
  m.product_id = (edid[0xb] << 8) + edid[0xa];
  if (edid[0x15] > 0 && edid[0x16] > 0) {
    m.width_mm = edid[0x15] * 10;
    m.height_mm = edid[0x16] * 10;
  }
  m.year = 1990 + edid[0x11];
  u = edid[0x23];
  if (u & (1 << 7))
    res[res_cnt].width = 720, res[res_cnt].height = 400,
    res[res_cnt].vfreq = 70, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 6))
    res[res_cnt].width = 720, res[res_cnt].height = 400,
    res[res_cnt].vfreq = 88, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 5))
    res[res_cnt].width = 640, res[res_cnt].height = 480,
    res[res_cnt].vfreq = 60, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 4))
    res[res_cnt].width = 640, res[res_cnt].height = 480,
    res[res_cnt].vfreq = 67, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 3))
    res[res_cnt].width = 640, res[res_cnt].height = 480,
    res[res_cnt].vfreq = 72, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 2))
    res[res_cnt].width = 640, res[res_cnt].height = 480,
    res[res_cnt].vfreq = 75, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 1))
    res[res_cnt].width = 800, res[res_cnt].height = 600,
    res[res_cnt].vfreq = 56, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 0))
    res[res_cnt].width = 800, res[res_cnt].height = 600,
    res[res_cnt].vfreq = 60, res[res_cnt++].il = 0;
  ;
  u = edid[0x24];
  if (u & (1 << 7))
    res[res_cnt].width = 800, res[res_cnt].height = 600,
    res[res_cnt].vfreq = 72, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 6))
    res[res_cnt].width = 800, res[res_cnt].height = 600,
    res[res_cnt].vfreq = 75, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 5))
    res[res_cnt].width = 832, res[res_cnt].height = 624,
    res[res_cnt].vfreq = 75, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 4))
    res[res_cnt].width = 1024, res[res_cnt].height = 768,
    res[res_cnt].vfreq = 87, res[res_cnt++].il = 1;
  ;
  if (u & (1 << 3))
    res[res_cnt].width = 1024, res[res_cnt].height = 768,
    res[res_cnt].vfreq = 60, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 2))
    res[res_cnt].width = 1024, res[res_cnt].height = 768,
    res[res_cnt].vfreq = 70, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 1))
    res[res_cnt].width = 1024, res[res_cnt].height = 768,
    res[res_cnt].vfreq = 75, res[res_cnt++].il = 0;
  ;
  if (u & (1 << 0))
    res[res_cnt].width = 1280, res[res_cnt].height = 1024,
    res[res_cnt].vfreq = 75, res[res_cnt++].il = 0;
  ;
  for (i = 0; i < 4; i++) {
    u1 = (edid[0x26 + 2 * i] + 31) * 8;
    u2 = edid[0x27 + 2 * i];
    u = 0;
    switch ((u2 >> 6) & 3) {
    case 1:
      u = (u1 * 3) / 4;
      break;
    case 2:
      u = (u1 * 4) / 5;
      break;
    case 3:
      u = (u1 * 9) / 16;
      break;
    }
    if (u) {
      res[res_cnt].width = u1, res[res_cnt].height = u,
      res[res_cnt].vfreq = (u2 & 0x3f) + 60, res[res_cnt++].il = 0;
      ;
    }
  }
  for (i = 0x36; i < 0x36 + 4 * 0x12; i += 0x12) {
    tag = (edid[i] << 24) + (edid[i + 1] << 16) + (edid[i + 2] << 8) +
          edid[i + 3];
    switch (tag) {
    case 0xfc:
      if (edid[i + 5]) {
        memcpy(m.product_name, canon_str(edid + i + 5, 0xd),
               sizeof m.product_name);
      }
      break;
    case 0xfd:
      u = 0;
      u1 = edid[i + 5];
      u2 = edid[i + 6];
      if (u1 > u2 || !u1)
        u = 1;
      m.min_vsync = u1;
      m.max_vsync = u2;
      u1 = edid[i + 7];
      u2 = edid[i + 8];
      if (u1 > u2 || !u1)
        u = 1;
      m.min_hsync = u1;
      m.max_hsync = u2;
      if (u) {
        m.min_vsync = m.max_vsync = m.min_hsync = m.max_hsync = 0;
      }
      break;
    case 0xfe:
      if (!*m.vendor_name && edid[i + 5]) {
        memcpy(m.vendor_name, canon_str(edid + i + 5, 0xd),
               sizeof m.vendor_name);
        for (s = m.vendor_name; *s; s++)
          if (*s < ' ')
            *s = ' ';
      }
      break;
    case 0xff:
      if (!*m.serial && edid[i + 5]) {
        memcpy(m.serial, canon_str(edid + i + 5, 0xd), sizeof m.serial);
        for (s = m.serial; *s; s++)
          if (*s < ' ')
            *s = ' ';
      }
      break;
    default:
      if (tag < 0x100) {
      } else {
        mi = mi_list + mi_cnt++;
        mi->width_mm = m.width_mm;
        mi->height_mm = m.height_mm;
        u = (edid[i + 0] + (edid[i + 1] << 8)) * 10;
        if (!u)
          break;
        mi->clock = u;
        u1 = edid[i + 2] + ((edid[i + 4] & 0xf0) << 4);
        u2 = edid[i + 5] + ((edid[i + 7] & 0xf0) << 4);
        if (!u1 || !u2 || u1 == 0xfff || u2 == 0xfff)
          break;
        mi->width = u1;
        mi->height = u2;
        u1 = edid[i + 12] + ((edid[i + 14] & 0xf0) << 4);
        u2 = edid[i + 13] + ((edid[i + 14] & 0xf) << 8);
        if (!u1 || !u2 || u1 == 0xfff || u2 == 0xfff)
          break;
        mi->width_mm = u1;
        mi->height_mm = u2;
        hblank = edid[i + 3] + ((edid[i + 4] & 0xf) << 8);
        hsync_ofs = edid[i + 8] + ((edid[i + 11] & 0xc0) << 2);
        hsync = edid[i + 9] + ((edid[i + 11] & 0x30) << 4);
        vblank = edid[i + 6] + ((edid[i + 7] & 0xf) << 8);
        vsync_ofs = ((edid[i + 10] & 0xf0) >> 4) + ((edid[i + 11] & 0x0c) << 2);
        vsync = (edid[i + 10] & 0xf) + ((edid[i + 11] & 0x03) << 4);
        mi->hdisp = mi->width;
        mi->hsyncstart = mi->width + hsync_ofs;
        mi->hsyncend = mi->width + hsync_ofs + hsync;
        mi->htotal = mi->width + hblank;
        mi->vdisp = mi->height;
        mi->vsyncstart = mi->height + vsync_ofs;
        mi->vsyncend = mi->height + vsync_ofs + vsync;
        mi->vtotal = mi->height + vblank;
        u = edid[i + 17];
        if (((u >> 3) & 3) == 3) {
          mi->hflag = (u & 4) ? '+' : '-';
          mi->vflag = (u & 2) ? '+' : '-';
        }
      }
    }
  }
  for (i = 0; i < mi_cnt; i++) {
    mi = mi_list + i;
    if (mi->width && mi->height) {
      res[res_cnt].width = mi->width, res[res_cnt].height = mi->height,
      res[res_cnt].vfreq = 60, res[res_cnt++].il = 0;
      ;
      if (mi->width_mm && mi->height_mm) {
        u = (mi->width_mm * mi->height * 16) / (mi->height_mm * mi->width);
        u1 = m.width_mm ? (m.width_mm * 16) / mi->width_mm : 16;
        u2 = m.height_mm ? (m.height_mm * 16) / mi->height_mm : 16;
        if (u <= 8 || u >= 32 || u1 <= 8 || u1 >= 32 || u2 <= 8 || u2 >= 32 ||
            mi->width_mm < 100 || mi->height_mm < 100) {
          if (m.width_mm && m.height_mm) {
            u = (m.width_mm * mi->height * 16) / (m.height_mm * mi->width);
            if (u > 8 && u < 32 && m.width_mm >= 100 && m.height_mm >= 100) {
              mi->width_mm = m.width_mm;
              mi->height_mm = m.height_mm;
            }
          }
          if (u <= 8 || u >= 32 || mi->width_mm < 100 || mi->height_mm < 100) {
            mi->width_mm = mi->height_mm = 0;
          }
        }
      }
    }
  }
  printf("Model: %s %04x", eisa_vendor(m.vendor_id), m.product_id);
  if (*m.vendor_name || *m.product_name) {
    printf(" (%s%s%s)", m.vendor_name, *m.vendor_name ? " " : "",
           m.product_name);
  }
  if (m.lcd)
    printf(" [LCD]");
  printf("\nManuf. Year: %u\n", m.year);
  if (mi_cnt) {
    u1 = mi_list[0].width_mm;
    u2 = mi_list[0].height_mm;
  } else {
    u1 = m.width_mm;
    u2 = m.height_mm;
  }
  printf("Size: %ux%u mm\n", u1, u2);
  printf("VSync: %u-%u Hz, HSync: %u-%u kHz\n", m.min_vsync, m.max_vsync,
         m.min_hsync, m.max_hsync);
  printf("Resolutions:\n");
  for (i = 0; i < res_cnt; i++) {
    printf("%s", i % 4 == 0 ? "  " : ", ");
    printf("%ux%u@%uHz%s", res[i].width, res[i].height, res[i].vfreq,
           res[i].il ? " (interlaced)" : "");
    printf("%s", i % 4 == 3 ? "\n" : "");
  }
  printf("%s", i % 4 ? "\n" : "");
  for (i = 0; i < mi_cnt; i++) {
    mi = mi_list + i;
    if (mi->htotal && mi->vtotal) {
      printf("Detailed Timings #%d:\n", i);
      printf("   Resolution: %ux%u\n", mi->width, mi->height);
      printf("   Horizontal: %4u %4u %4u %4u (+%u +%u +%u) %chsync\n",
             mi->hdisp, mi->hsyncstart, mi->hsyncend, mi->htotal,
             mi->hsyncstart - mi->hdisp, mi->hsyncend - mi->hdisp,
             mi->htotal - mi->hdisp, mi->hflag);
      printf("     Vertical: %4u %4u %4u %4u (+%u +%u +%u) %cvsync\n",
             mi->vdisp, mi->vsyncstart, mi->vsyncend, mi->vtotal,
             mi->vsyncstart - mi->vdisp, mi->vsyncend - mi->vdisp,
             mi->vtotal - mi->vdisp, mi->vflag);
      printf("  Frequencies: %u.%02u MHz, %u.%02u kHz, %u.%02u Hz\n",
             mi->clock / 1000, (mi->clock * 100 / 1000) % 100,
             mi->clock / mi->htotal, (mi->clock * 100 / mi->htotal) % 100,
             mi->clock * 1000 / mi->htotal / mi->vtotal, 0);
    }
  }
  printf("\n");
}


x86 assembly (clang, -O0):
<print_edid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x550,%rsp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
lea    -0x280(%rbp),%rdi
xor    %esi,%esi
mov    $0x1c0,%edx
call   1070 <memset@plt>
lea    -0x370(%rbp),%rdi
xor    %esi,%esi
mov    $0xf0,%edx
call   1070 <memset@plt>
lea    -0x500(%rbp),%rdi
xor    %esi,%esi
mov    $0x180,%edx
call   1070 <memset@plt>
mov    -0x4(%rbp),%edi
lea    -0xa0(%rbp),%rsi
mov    $0x0,%al
call   1090 <probe_ddc@plt>
mov    %eax,-0xc(%rbp)
lea    -0xa0(%rbp),%rdi
mov    $0x0,%al
call   1040 <chk_edid_info@plt>
cmp    $0x0,%eax
jne    1209 <print_edid+0x99>
mov    -0x4(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0x1e13(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    2b98 <print_edid+0x1a28>
movzbl -0x8c(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     122e <print_edid+0xbe>
mov    -0x280(%rbp),%al
and    $0xfe,%al
or     $0x1,%al
mov    %al,-0x280(%rbp)
movzbl -0x98(%rbp),%eax
shl    $0x8,%eax
movzbl -0x97(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x27c(%rbp)
movzbl -0x95(%rbp),%eax
shl    $0x8,%eax
movzbl -0x96(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x278(%rbp)
movzbl -0x8b(%rbp),%eax
cmp    $0x0,%eax
jle    12a0 <print_edid+0x130>
movzbl -0x8a(%rbp),%eax
cmp    $0x0,%eax
jle    12a0 <print_edid+0x130>
movzbl -0x8b(%rbp),%eax
imul   $0xa,%eax,%eax
mov    %eax,-0x274(%rbp)
movzbl -0x8a(%rbp),%eax
imul   $0xa,%eax,%eax
mov    %eax,-0x270(%rbp)
movzbl -0x8f(%rbp),%eax
add    $0x7c6,%eax
mov    %eax,-0x26c(%rbp)
movzbl -0x7d(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     133b <print_edid+0x1cb>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x2d0,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x190,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x46,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     13bb <print_edid+0x24b>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x2d0,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x190,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x58,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     143b <print_edid+0x2cb>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x280,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x1e0,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x3c,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     14bb <print_edid+0x34b>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x280,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x1e0,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x43,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     153b <print_edid+0x3cb>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x280,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x1e0,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x48,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     15bb <print_edid+0x44b>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x280,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x1e0,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x4b,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     163b <print_edid+0x4cb>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x320,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x258,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x38,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     16bb <print_edid+0x54b>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x320,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x258,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x3c,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
movzbl -0x7c(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1744 <print_edid+0x5d4>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x320,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x258,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x48,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     17c4 <print_edid+0x654>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x320,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x258,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x4b,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     1844 <print_edid+0x6d4>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x340,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x270,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x4b,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     18c4 <print_edid+0x754>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x400,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x300,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x57,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x1,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1944 <print_edid+0x7d4>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x400,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x300,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x3c,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     19c4 <print_edid+0x854>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x400,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x300,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x46,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1a44 <print_edid+0x8d4>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x400,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x300,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x4b,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1ac4 <print_edid+0x954>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x500,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x400,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x4b,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
movl   $0x0,-0x8(%rbp)
cmpl   $0x4,-0x8(%rbp)
jge    1c10 <print_edid+0xaa0>
mov    -0x8(%rbp),%eax
add    %eax,%eax
cltq
lea    -0xa0(%rbp),%rcx
movzbl 0x26(%rax,%rcx,1),%edx
mov    %edx,%eax
lea    0xf8(,%rax,8),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
add    %eax,%eax
cltq
movzbl 0x27(%rax,%rcx,1),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x14(%rbp),%eax
shr    $0x6,%eax
and    $0x3,%eax
mov    %eax,-0x504(%rbp)
sub    $0x1,%eax
je     1b4f <print_edid+0x9df>
jmp    1b27 <print_edid+0x9b7>
mov    -0x504(%rbp),%eax
sub    $0x2,%eax
je     1b5e <print_edid+0x9ee>
jmp    1b3b <print_edid+0x9cb>
mov    -0x504(%rbp),%eax
sub    $0x3,%eax
je     1b75 <print_edid+0xa05>
jmp    1b7f <print_edid+0xa0f>
imul   $0x3,-0x10(%rbp),%eax
shr    $0x2,%eax
mov    %eax,-0xc(%rbp)
jmp    1b7f <print_edid+0xa0f>
mov    -0x10(%rbp),%eax
shl    $0x2,%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,-0xc(%rbp)
jmp    1b7f <print_edid+0xa0f>
imul   $0x9,-0x10(%rbp),%eax
shr    $0x4,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     1bfd <print_edid+0xa8d>
mov    -0x10(%rbp),%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
lea    -0x500(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
lea    -0x500(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
mov    -0x14(%rbp),%ecx
and    $0x3f,%ecx
add    $0x3c,%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
lea    -0x500(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
jmp    1c02 <print_edid+0xa92>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1acb <print_edid+0x95b>
movl   $0x36,-0x8(%rbp)
cmpl   $0x7e,-0x8(%rbp)
jge    23b1 <print_edid+0x1241>
movslq -0x8(%rbp),%rax
mov    -0xa0(%rbp,%rax,1),%eax
bswap  %eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffff04,%eax
mov    %eax,%ecx
mov    %rcx,-0x510(%rbp)
sub    $0x3,%eax
ja     1f4d <print_edid+0xddd>
mov    -0x510(%rbp),%rax
lea    0x13a7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%eax
add    $0x5,%eax
cltq
cmpb   $0x0,-0xa0(%rbp,%rax,1)
je     1cbe <print_edid+0xb4e>
lea    -0x280(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0x518(%rbp)
lea    -0xa0(%rbp),%rdi
movslq -0x8(%rbp),%rax
add    %rax,%rdi
add    $0x5,%rdi
mov    $0xd,%esi
mov    $0x0,%al
call   1060 <canon_str@plt>
mov    -0x518(%rbp),%rdi
movslq %eax,%rsi
mov    $0x80,%edx
call   1080 <memcpy@plt>
jmp    239e <print_edid+0x122e>
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%eax
add    $0x5,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
add    $0x6,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
ja     1d06 <print_edid+0xb96>
cmpl   $0x0,-0x10(%rbp)
jne    1d0d <print_edid+0xb9d>
movl   $0x1,-0xc(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x268(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x264(%rbp)
mov    -0x8(%rbp),%eax
add    $0x7,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
add    $0x8,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
ja     1d5b <print_edid+0xbeb>
cmpl   $0x0,-0x10(%rbp)
jne    1d62 <print_edid+0xbf2>
movl   $0x1,-0xc(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x260(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x25c(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     1da6 <print_edid+0xc36>
movl   $0x0,-0x25c(%rbp)
movl   $0x0,-0x260(%rbp)
movl   $0x0,-0x264(%rbp)
movl   $0x0,-0x268(%rbp)
jmp    239e <print_edid+0x122e>
cmpb   $0x0,-0x240(%rbp)
jne    1e75 <print_edid+0xd05>
mov    -0x8(%rbp),%eax
add    $0x5,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     1e75 <print_edid+0xd05>
lea    -0x280(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x520(%rbp)
lea    -0xa0(%rbp),%rdi
movslq -0x8(%rbp),%rax
add    %rax,%rdi
add    $0x5,%rdi
mov    $0xd,%esi
mov    $0x0,%al
call   1060 <canon_str@plt>
mov    -0x520(%rbp),%rdi
movslq %eax,%rsi
mov    $0x80,%edx
call   1080 <memcpy@plt>
lea    -0x280(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
cmpb   $0x0,(%rax)
je     1e70 <print_edid+0xd00>
mov    -0xc0(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jge    1e54 <print_edid+0xce4>
mov    -0xc0(%rbp),%rax
movb   $0x20,(%rax)
jmp    1e59 <print_edid+0xce9>
mov    -0xc0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
jmp    1e27 <print_edid+0xcb7>
jmp    1e75 <print_edid+0xd05>
jmp    239e <print_edid+0x122e>
cmpb   $0x0,-0x140(%rbp)
jne    1f48 <print_edid+0xdd8>
mov    -0x8(%rbp),%eax
add    $0x5,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     1f48 <print_edid+0xdd8>
lea    -0x280(%rbp),%rax
add    $0x140,%rax
mov    %rax,-0x528(%rbp)
lea    -0xa0(%rbp),%rdi
movslq -0x8(%rbp),%rax
add    %rax,%rdi
add    $0x5,%rdi
mov    $0xd,%esi
mov    $0x0,%al
call   1060 <canon_str@plt>
mov    -0x528(%rbp),%rdi
movslq %eax,%rsi
mov    $0x80,%edx
call   1080 <memcpy@plt>
lea    -0x280(%rbp),%rax
add    $0x140,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
cmpb   $0x0,(%rax)
je     1f43 <print_edid+0xdd3>
mov    -0xc0(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jge    1f27 <print_edid+0xdb7>
mov    -0xc0(%rbp),%rax
movb   $0x20,(%rax)
jmp    1f2c <print_edid+0xdbc>
mov    -0xc0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
jmp    1efa <print_edid+0xd8a>
jmp    1f48 <print_edid+0xdd8>
jmp    239e <print_edid+0x122e>
cmpl   $0x100,-0x18(%rbp)
jae    1f5f <print_edid+0xdef>
jmp    2399 <print_edid+0x1229>
lea    -0x370(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
mov    %ecx,%ecx
imul   $0x3c,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x378(%rbp)
mov    -0x274(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x270(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%eax
add    $0x0,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
shl    $0x8,%ecx
add    %ecx,%eax
imul   $0xa,%eax,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1fdc <print_edid+0xe6c>
jmp    239e <print_edid+0x122e>
mov    -0xc(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%eax
add    $0x2,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
and    $0xf0,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
add    $0x5,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xf0,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     2075 <print_edid+0xf05>
cmpl   $0x0,-0x14(%rbp)
je     2075 <print_edid+0xf05>
cmpl   $0xfff,-0x10(%rbp)
je     2075 <print_edid+0xf05>
cmpl   $0xfff,-0x14(%rbp)
jne    207a <print_edid+0xf0a>
jmp    239e <print_edid+0x122e>
mov    -0x10(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%eax
add    $0xc,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xf0,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
add    $0xd,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xf,%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     211c <print_edid+0xfac>
cmpl   $0x0,-0x14(%rbp)
je     211c <print_edid+0xfac>
cmpl   $0xfff,-0x10(%rbp)
je     211c <print_edid+0xfac>
cmpl   $0xfff,-0x14(%rbp)
jne    2121 <print_edid+0xfb1>
jmp    239e <print_edid+0x122e>
mov    -0x10(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%eax
add    $0x3,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xf,%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x8(%rbp),%eax
add    $0x8,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xc0,%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x8(%rbp),%eax
add    $0x9,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0x30,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%eax
add    $0x6,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    -0x8(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xf,%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x8(%rbp),%eax
add    $0xa,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
and    $0xf0,%eax
sar    $0x4,%eax
mov    -0x8(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0xc,%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x8(%rbp),%eax
add    $0xa,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
and    $0xf,%eax
mov    -0x8(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movzbl -0xa0(%rbp,%rcx,1),%ecx
ff
and    $0x3,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x378(%rbp),%rax
mov    (%rax),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x378(%rbp),%rax
mov    (%rax),%ecx
add    -0xa8(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x378(%rbp),%rax
mov    (%rax),%ecx
add    -0xa8(%rbp),%ecx
add    -0xac(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x378(%rbp),%rax
mov    (%rax),%ecx
add    -0xa4(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x20(%rax)
mov    -0x378(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x28(%rax)
mov    -0x378(%rbp),%rax
mov    0x4(%rax),%ecx
add    -0xb4(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x2c(%rax)
mov    -0x378(%rbp),%rax
mov    0x4(%rax),%ecx
add    -0xb4(%rbp),%ecx
add    -0xb8(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x30(%rax)
mov    -0x378(%rbp),%rax
mov    0x4(%rax),%ecx
add    -0xb0(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x34(%rax)
mov    -0x8(%rbp),%eax
add    $0x11,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
shr    $0x3,%eax
and    $0x3,%eax
cmp    $0x3,%eax
jne    2394 <print_edid+0x1224>
mov    -0xc(%rbp),%edx
and    $0x4,%edx
mov    $0x2d,%ecx
mov    $0x2b,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x24(%rax)
mov    -0xc(%rbp),%edx
and    $0x2,%edx
mov    $0x2d,%ecx
mov    $0x2b,%eax
cmp    $0x0,%edx
cmovne %eax,%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x38(%rax)
jmp    2399 <print_edid+0x1229>
jmp    239e <print_edid+0x122e>
jmp    23a3 <print_edid+0x1233>
mov    -0x8(%rbp),%eax
add    $0x12,%eax
mov    %eax,-0x8(%rbp)
jmp    1c17 <print_edid+0xaa7>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    26c5 <print_edid+0x1555>
lea    -0x370(%rbp),%rax
movslq -0x8(%rbp),%rcx
imul   $0x3c,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x378(%rbp)
mov    -0x378(%rbp),%rax
cmpl   $0x0,(%rax)
je     26b2 <print_edid+0x1542>
mov    -0x378(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     26b2 <print_edid+0x1542>
mov    -0x378(%rbp),%rax
mov    (%rax),%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
lea    -0x500(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x378(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
lea    -0x500(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x3c,0x8(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x0,0xc(%rax)
mov    -0x378(%rbp),%rax
cmpl   $0x0,0x8(%rax)
je     26ad <print_edid+0x153d>
mov    -0x378(%rbp),%rax
cmpl   $0x0,0xc(%rax)
je     26ad <print_edid+0x153d>
mov    -0x378(%rbp),%rax
mov    0x8(%rax),%eax
mov    -0x378(%rbp),%rcx
imul   0x4(%rcx),%eax
shl    $0x4,%eax
mov    -0x378(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x378(%rbp),%rdx
imul   (%rdx),%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0x274(%rbp)
je     24fc <print_edid+0x138c>
mov    -0x274(%rbp),%eax
shl    $0x4,%eax
mov    -0x378(%rbp),%rcx
xor    %edx,%edx
divl   0x8(%rcx)
mov    %eax,-0x52c(%rbp)
jmp    250c <print_edid+0x139c>
mov    $0x10,%eax
mov    %eax,-0x52c(%rbp)
jmp    250c <print_edid+0x139c>
mov    -0x52c(%rbp),%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x270(%rbp)
je     2542 <print_edid+0x13d2>
mov    -0x270(%rbp),%eax
shl    $0x4,%eax
mov    -0x378(%rbp),%rcx
xor    %edx,%edx
divl   0xc(%rcx)
mov    %eax,-0x530(%rbp)
jmp    2552 <print_edid+0x13e2>
mov    $0x10,%eax
mov    %eax,-0x530(%rbp)
jmp    2552 <print_edid+0x13e2>
mov    -0x530(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x8,-0xc(%rbp)
jbe    25b9 <print_edid+0x1449>
cmpl   $0x20,-0xc(%rbp)
jae    25b9 <print_edid+0x1449>
cmpl   $0x8,-0x10(%rbp)
jbe    25b9 <print_edid+0x1449>
cmpl   $0x20,-0x10(%rbp)
jae    25b9 <print_edid+0x1449>
cmpl   $0x8,-0x14(%rbp)
jbe    25b9 <print_edid+0x1449>
cmpl   $0x20,-0x14(%rbp)
jae    25b9 <print_edid+0x1449>
mov    -0x378(%rbp),%rax
cmpl   $0x64,0x8(%rax)
jb     25b9 <print_edid+0x1449>
mov    -0x378(%rbp),%rax
cmpl   $0x64,0xc(%rax)
jae    26a8 <print_edid+0x1538>
cmpl   $0x0,-0x274(%rbp)
je     2651 <print_edid+0x14e1>
cmpl   $0x0,-0x270(%rbp)
je     2651 <print_edid+0x14e1>
mov    -0x274(%rbp),%eax
mov    -0x378(%rbp),%rcx
imul   0x4(%rcx),%eax
shl    $0x4,%eax
mov    -0x270(%rbp),%ecx
mov    -0x378(%rbp),%rdx
imul   (%rdx),%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,-0xc(%rbp)
cmpl   $0x8,-0xc(%rbp)
jbe    264c <print_edid+0x14dc>
cmpl   $0x20,-0xc(%rbp)
jae    264c <print_edid+0x14dc>
cmpl   $0x64,-0x274(%rbp)
jb     264c <print_edid+0x14dc>
cmpl   $0x64,-0x270(%rbp)
jb     264c <print_edid+0x14dc>
mov    -0x274(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x270(%rbp),%ecx
mov    -0x378(%rbp),%rax
mov    %ecx,0xc(%rax)
jmp    2651 <print_edid+0x14e1>
cmpl   $0x8,-0xc(%rbp)
jbe    2687 <print_edid+0x1517>
cmpl   $0x20,-0xc(%rbp)
jae    2687 <print_edid+0x1517>
mov    -0x378(%rbp),%rax
cmpl   $0x64,0x8(%rax)
jb     2687 <print_edid+0x1517>
mov    -0x378(%rbp),%rax
cmpl   $0x64,0xc(%rax)
jae    26a3 <print_edid+0x1533>
mov    -0x378(%rbp),%rax
movl   $0x0,0xc(%rax)
mov    -0x378(%rbp),%rax
movl   $0x0,0x8(%rax)
jmp    26a8 <print_edid+0x1538>
jmp    26ad <print_edid+0x153d>
jmp    26b2 <print_edid+0x1542>
jmp    26b7 <print_edid+0x1547>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    23b8 <print_edid+0x1248>
mov    -0x27c(%rbp),%edi
mov    $0x0,%al
call   1030 <eisa_vendor@plt>
mov    %eax,%esi
mov    -0x278(%rbp),%edx
lea    0x957(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movsbl -0x240(%rbp),%eax
cmp    $0x0,%eax
jne    2708 <print_edid+0x1598>
movsbl -0x1c0(%rbp),%eax
cmp    $0x0,%eax
je     274b <print_edid+0x15db>
lea    -0x280(%rbp),%rsi
add    $0x40,%rsi
movsbl -0x240(%rbp),%ecx
lea    0x916(%rip),%rdx
lea    0x984(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
lea    -0x280(%rbp),%rcx
add    $0xc0,%rcx
lea    0x903(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x280(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
cmp    $0x0,%eax
je     276d <print_edid+0x15fd>
lea    0x8eb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x26c(%rbp),%esi
lea    0x8de(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x0,-0x1c(%rbp)
je     27a2 <print_edid+0x1632>
mov    -0x368(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x364(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    27b4 <print_edid+0x1644>
mov    -0x274(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x270(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%esi
mov    -0x14(%rbp),%edx
lea    0x8a9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x268(%rbp),%esi
mov    -0x264(%rbp),%edx
mov    -0x260(%rbp),%ecx
mov    -0x25c(%rbp),%r8d
lea    0x892(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x8a7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    28f0 <print_edid+0x1780>
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
lea    0x88c(%rip),%rsi
lea    0x882(%rip),%rax
cmp    $0x0,%edx
cmove  %rax,%rsi
lea    0x884(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x8(%rbp),%rcx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%esi
movslq -0x8(%rbp),%rcx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
movslq -0x8(%rbp),%rcx
lea    -0x500(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
movslq -0x8(%rbp),%rdi
lea    -0x500(%rbp),%rax
shl    $0x4,%rdi
add    %rdi,%rax
mov    0xc(%rax),%edi
lea    0x79f(%rip),%r8
lea    0x81f(%rip),%rax
cmp    $0x0,%edi
cmovne %rax,%r8
lea    0x804(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
lea    0x771(%rip),%rsi
lea    0x769(%rip),%rax
cmp    $0x3,%edx
cmove  %rax,%rsi
lea    0x7e0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    2804 <print_edid+0x1694>
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
lea    0x735(%rip),%rsi
lea    0x72d(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rsi
lea    0x7a4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    2b8a <print_edid+0x1a1a>
lea    -0x370(%rbp),%rax
movslq -0x8(%rbp),%rcx
imul   $0x3c,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x378(%rbp)
mov    -0x378(%rbp),%rax
cmpl   $0x0,0x20(%rax)
je     2b77 <print_edid+0x1a07>
mov    -0x378(%rbp),%rax
cmpl   $0x0,0x34(%rax)
je     2b77 <print_edid+0x1a07>
mov    -0x8(%rbp),%esi
lea    0x756(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x378(%rbp),%rax
mov    (%rax),%esi
mov    -0x378(%rbp),%rax
mov    0x4(%rax),%edx
lea    0x74c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x378(%rbp),%rax
mov    0x14(%rax),%esi
mov    -0x378(%rbp),%rax
mov    0x18(%rax),%edx
mov    -0x378(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x378(%rbp),%rax
mov    0x20(%rax),%r8d
mov    -0x378(%rbp),%rax
mov    0x18(%rax),%r9d
mov    -0x378(%rbp),%rax
sub    0x14(%rax),%r9d
mov    -0x378(%rbp),%rax
mov    0x1c(%rax),%r11d
mov    -0x378(%rbp),%rax
sub    0x14(%rax),%r11d
mov    -0x378(%rbp),%rax
mov    0x20(%rax),%r10d
mov    -0x378(%rbp),%rax
sub    0x14(%rax),%r10d
mov    -0x378(%rbp),%rax
mov    0x24(%rax),%eax
lea    0x6df(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x378(%rbp),%rax
mov    0x28(%rax),%esi
mov    -0x378(%rbp),%rax
mov    0x2c(%rax),%edx
mov    -0x378(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x378(%rbp),%rax
mov    0x34(%rax),%r8d
mov    -0x378(%rbp),%rax
mov    0x2c(%rax),%r9d
mov    -0x378(%rbp),%rax
sub    0x28(%rax),%r9d
mov    -0x378(%rbp),%rax
mov    0x30(%rax),%r11d
mov    -0x378(%rbp),%rax
sub    0x28(%rax),%r11d
mov    -0x378(%rbp),%rax
mov    0x34(%rax),%r10d
mov    -0x378(%rbp),%rax
sub    0x28(%rax),%r10d
mov    -0x378(%rbp),%rax
mov    0x38(%rax),%eax
lea    0x685(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x378(%rbp),%rax
mov    0x10(%rax),%eax
mov    $0x3e8,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%esi
mov    -0x378(%rbp),%rax
imul   $0x64,0x10(%rax),%eax
mov    $0x3e8,%ecx
xor    %edx,%edx
div    %ecx
mov    $0x64,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,-0x534(%rbp)
mov    -0x378(%rbp),%rax
mov    0x10(%rax),%eax
mov    -0x378(%rbp),%rcx
xor    %edx,%edx
divl   0x20(%rcx)
mov    %eax,%ecx
mov    -0x378(%rbp),%rax
imul   $0x64,0x10(%rax),%eax
mov    -0x378(%rbp),%rdi
xor    %edx,%edx
divl   0x20(%rdi)
mov    $0x64,%edi
xor    %edx,%edx
div    %edi
mov    %edx,%r8d
mov    -0x378(%rbp),%rax
imul   $0x3e8,0x10(%rax),%eax
mov    -0x378(%rbp),%rdi
xor    %edx,%edx
divl   0x20(%rdi)
mov    -0x378(%rbp),%rdi
xor    %edx,%edx
divl   0x34(%rdi)
mov    -0x534(%rbp),%edx
mov    %eax,%r9d
lea    0x5fe(%rip),%rdi
xor    %eax,%eax
movl   $0x0,(%rsp)
mov    $0x0,%al
call   1050 <printf@plt>
jmp    2b7c <print_edid+0x1a0c>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    2925 <print_edid+0x17b5>
lea    0x4a5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
add    $0x550,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_edid>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4d8,%rsp
mov    %edi,%ebp
lea    0x318(%rsp),%rdi
mov    $0x1c0,%edx
xor    %esi,%esi
call   1090 <memset@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps %xmm0,0x170(%rsp)
movaps %xmm0,0x160(%rsp)
movaps %xmm0,0x150(%rsp)
movaps %xmm0,0x140(%rsp)
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
lea    0x190(%rsp),%rdi
mov    $0x180,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0x20(%rsp),%r12
mov    %ebp,%edi
mov    %r12,%rsi
xor    %eax,%eax
call   10a0 <probe_ddc@plt>
mov    %eax,%ebx
mov    %r12,%rdi
xor    %eax,%eax
call   1060 <chk_edid_info@plt>
test   %eax,%eax
je     13b4 <print_edid+0x234>
cmpb   $0x0,0x34(%rsp)
jns    126a <print_edid+0xea>
orb    $0x1,0x318(%rsp)
01
movzwl 0x28(%rsp),%eax
shl    $0x10,%eax
bswap  %eax
mov    %eax,0x31c(%rsp)
movzwl 0x2a(%rsp),%eax
mov    %eax,0x320(%rsp)
movzbl 0x35(%rsp),%eax
test   %eax,%eax
je     12b3 <print_edid+0x133>
mov    0x36(%rsp),%cl
test   %cl,%cl
je     12b3 <print_edid+0x133>
movzbl %cl,%ecx
add    %eax,%eax
lea    (%rax,%rax,4),%eax
mov    %eax,0x324(%rsp)
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%eax
mov    %eax,0x328(%rsp)
movzbl 0x31(%rsp),%eax
add    $0x7c6,%eax
mov    %eax,0x32c(%rsp)
movzbl 0x43(%rsp),%eax
xor    %edi,%edi
test   $0x80,%al
jne    13cb <print_edid+0x24b>
test   $0x40,%al
jne    13e7 <print_edid+0x267>
test   $0x20,%al
jne    1407 <print_edid+0x287>
test   $0x10,%al
jne    1427 <print_edid+0x2a7>
test   $0x8,%al
jne    1447 <print_edid+0x2c7>
test   $0x4,%al
jne    1467 <print_edid+0x2e7>
test   $0x2,%al
jne    1487 <print_edid+0x307>
test   $0x1,%al
je     131f <print_edid+0x19f>
mov    %edi,%eax
shl    $0x4,%rax
add    $0x1,%edi
movaps 0x1d59(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rax,1)
movzbl 0x44(%rsp),%eax
test   $0x80,%al
jne    14ac <print_edid+0x32c>
test   $0x40,%al
jne    14cc <print_edid+0x34c>
test   $0x20,%al
jne    14ec <print_edid+0x36c>
test   $0x10,%al
jne    150c <print_edid+0x38c>
test   $0x8,%al
jne    152c <print_edid+0x3ac>
test   $0x4,%al
jne    154c <print_edid+0x3cc>
test   $0x2,%al
jne    156c <print_edid+0x3ec>
test   $0x1,%al
je     1378 <print_edid+0x1f8>
mov    %edi,%eax
shl    $0x4,%rax
add    $0x1,%edi
movaps 0x1d80(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rax,1)
movzbl 0x46(%rsp),%eax
lea    0xf8(,%rax,8),%ecx
movzbl 0x47(%rsp),%eax
mov    %eax,%edx
shr    $0x6,%edx
cmp    $0x3,%edx
je     1591 <print_edid+0x411>
cmp    $0x2,%edx
je     1599 <print_edid+0x419>
cmp    $0x1,%edx
jne    15d1 <print_edid+0x451>
lea    (%rcx,%rcx,2),%edx
shr    $0x2,%edx
jmp    15a2 <print_edid+0x422>
lea    0x1d65(%rip),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <printf@plt>
jmp    20f4 <print_edid+0xf74>
movaps 0x1c2e(%rip),%xmm0
movaps %xmm0,0x190(%rsp)
mov    $0x1,%edi
test   $0x40,%al
je     12db <print_edid+0x15b>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1c19(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x20,%al
je     12e3 <print_edid+0x163>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1c09(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x10,%al
je     12eb <print_edid+0x16b>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1bf9(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x8,%al
je     12f3 <print_edid+0x173>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1be9(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x4,%al
je     12fb <print_edid+0x17b>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1bd9(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x2,%al
je     1303 <print_edid+0x183>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1bc9(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x1,%al
jne    1307 <print_edid+0x187>
jmp    131f <print_edid+0x19f>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1bc4(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x40,%al
je     1334 <print_edid+0x1b4>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1bb4(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x20,%al
je     133c <print_edid+0x1bc>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1ba4(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x10,%al
je     1344 <print_edid+0x1c4>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1b94(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x8,%al
je     134c <print_edid+0x1cc>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1b84(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x4,%al
je     1354 <print_edid+0x1d4>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1b74(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x2,%al
je     135c <print_edid+0x1dc>
mov    %edi,%ecx
shl    $0x4,%rcx
add    $0x1,%edi
movaps 0x1b64(%rip),%xmm0
movaps %xmm0,0x190(%rsp,%rcx,1)
test   $0x1,%al
jne    1360 <print_edid+0x1e0>
jmp    1378 <print_edid+0x1f8>
lea    (%rcx,%rcx,8),%edx
shr    $0x4,%edx
jmp    15a2 <print_edid+0x422>
imul   $0x33334,%ecx,%edx
shr    $0x12,%edx
mov    %edi,%esi
shl    $0x4,%rsi
mov    %ecx,0x190(%rsp,%rsi,1)
mov    %edx,0x194(%rsp,%rsi,1)
and    $0x3f,%eax
add    $0x3c,%eax
mov    %eax,0x198(%rsp,%rsi,1)
add    $0x1,%edi
movl   $0x0,0x19c(%rsp,%rsi,1)
movzbl 0x48(%rsp),%eax
lea    0xf8(,%rax,8),%ecx
movzbl 0x49(%rsp),%eax
mov    %eax,%edx
shr    $0x6,%edx
cmp    $0x1,%edx
je     15fe <print_edid+0x47e>
cmp    $0x2,%edx
je     1606 <print_edid+0x486>
cmp    $0x3,%edx
jne    163e <print_edid+0x4be>
lea    (%rcx,%rcx,8),%edx
shr    $0x4,%edx
jmp    160f <print_edid+0x48f>
lea    (%rcx,%rcx,2),%edx
shr    $0x2,%edx
jmp    160f <print_edid+0x48f>
imul   $0x33334,%ecx,%edx
shr    $0x12,%edx
mov    %edi,%esi
shl    $0x4,%rsi
mov    %ecx,0x190(%rsp,%rsi,1)
mov    %edx,0x194(%rsp,%rsi,1)
and    $0x3f,%eax
add    $0x3c,%eax
mov    %eax,0x198(%rsp,%rsi,1)
add    $0x1,%edi
movl   $0x0,0x19c(%rsp,%rsi,1)
movzbl 0x4a(%rsp),%eax
lea    0xf8(,%rax,8),%ecx
movzbl 0x4b(%rsp),%eax
mov    %eax,%edx
shr    $0x6,%edx
cmp    $0x1,%edx
je     166b <print_edid+0x4eb>
cmp    $0x2,%edx
je     1673 <print_edid+0x4f3>
cmp    $0x3,%edx
jne    16ab <print_edid+0x52b>
lea    (%rcx,%rcx,8),%edx
shr    $0x4,%edx
jmp    167c <print_edid+0x4fc>
lea    (%rcx,%rcx,2),%edx
shr    $0x2,%edx
jmp    167c <print_edid+0x4fc>
imul   $0x33334,%ecx,%edx
shr    $0x12,%edx
mov    %edi,%esi
shl    $0x4,%rsi
mov    %ecx,0x190(%rsp,%rsi,1)
mov    %edx,0x194(%rsp,%rsi,1)
and    $0x3f,%eax
add    $0x3c,%eax
mov    %eax,0x198(%rsp,%rsi,1)
add    $0x1,%edi
movl   $0x0,0x19c(%rsp,%rsi,1)
movzbl 0x4c(%rsp),%eax
lea    0xf8(,%rax,8),%ecx
movzbl 0x4d(%rsp),%eax
mov    %eax,%edx
shr    $0x6,%edx
cmp    $0x1,%edx
je     16d8 <print_edid+0x558>
cmp    $0x2,%edx
je     16e0 <print_edid+0x560>
cmp    $0x3,%edx
jne    171e <print_edid+0x59e>
lea    (%rcx,%rcx,8),%edx
shr    $0x4,%edx
jmp    16e9 <print_edid+0x569>
lea    (%rcx,%rcx,2),%edx
shr    $0x2,%edx
jmp    16e9 <print_edid+0x569>
imul   $0x33334,%ecx,%edx
shr    $0x12,%edx
mov    %edi,%esi
shl    $0x4,%rsi
mov    %ecx,0x190(%rsp,%rsi,1)
mov    %edx,0x194(%rsp,%rsi,1)
and    $0x3f,%eax
add    $0x3c,%eax
mov    %eax,0x198(%rsp,%rsi,1)
add    $0x1,%edi
mov    %edi,0xc(%rsp)
movl   $0x0,0x19c(%rsp,%rsi,1)
jmp    1722 <print_edid+0x5a2>
mov    %edi,0xc(%rsp)
lea    0x458(%rsp),%r14
mov    $0x36,%r15d
lea    0x19d9(%rip),%r13
movl   $0x0,0x10(%rsp)
jmp    1761 <print_edid+0x5e1>
xorps  %xmm0,%xmm0
movups %xmm0,-0x128(%r14)
ff
nopl   0x0(%rax)
lea    0x12(%r15),%rax
cmp    $0x6c,%r15
mov    %rax,%r15
jae    1bda <print_edid+0xa5a>
movzbl 0x20(%rsp,%r15,1),%edx
mov    %edx,%eax
shl    $0x18,%eax
mov    %r15,%rcx
or     $0x1,%rcx
movzbl 0x20(%rsp,%rcx,1),%ecx
mov    %ecx,%edi
shl    $0x10,%edi
or     %eax,%edi
movzbl 0x22(%rsp,%r15,1),%esi
mov    %esi,%eax
shl    $0x8,%eax
or     %edi,%eax
movzbl 0x23(%rsp,%r15,1),%ebx
lea    (%rbx,%rax,1),%ebp
add    $0xffffff04,%ebp
cmp    $0x3,%ebp
ja     1820 <print_edid+0x6a0>
lea    (%rsp,%r15,1),%rdi
add    $0x20,%rdi
movslq 0x0(%r13,%rbp,4),%rax
add    %r13,%rax
jmp    *%rax
cmpb   $0x0,0x5(%r15,%r12,1)
je     1750 <print_edid+0x5d0>
add    $0x5,%rdi
mov    $0xd,%esi
xor    %eax,%eax
call   1080 <canon_str@plt>
cltq
movups (%rax),%xmm0
movups 0x10(%rax),%xmm1
movups 0x20(%rax),%xmm2
movups 0x30(%rax),%xmm3
lea    0x3d8(%rsp),%rcx
movups %xmm0,(%rcx)
movups %xmm1,0x10(%rcx)
movups %xmm2,0x20(%rcx)
movups %xmm3,0x30(%rcx)
movups 0x40(%rax),%xmm0
movups %xmm0,0x40(%rcx)
movups 0x50(%rax),%xmm0
movups %xmm0,0x50(%rcx)
movups 0x60(%rax),%xmm0
movups %xmm0,0x60(%rcx)
movups 0x70(%rax),%xmm0
movups %xmm0,0x70(%rcx)
jmp    1750 <print_edid+0x5d0>
nopl   0x0(%rax,%rax,1)
or     %ebx,%eax
cmp    $0x100,%eax
jb     1750 <print_edid+0x5d0>
mov    0x10(%rsp),%edi
mov    %edi,%eax
add    $0x1,%edi
mov    %edi,0x10(%rsp)
mov    0x324(%rsp),%edi
imul   $0x3c,%rax,%rax
mov    %edi,0xa8(%rsp,%rax,1)
mov    0x328(%rsp),%edi
mov    %edi,0xac(%rsp,%rax,1)
shl    $0x8,%ecx
or     %edx,%ecx
je     1750 <print_edid+0x5d0>
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
mov    %ecx,0xb0(%rsp,%rax,1)
movzbl 0x4(%r15,%r12,1),%r11d
mov    %r11d,%edx
and    $0xfffffff0,%edx
shl    $0x4,%edx
or     %esi,%edx
cmp    $0xfff,%edx
je     1750 <print_edid+0x5d0>
test   %edx,%edx
je     1750 <print_edid+0x5d0>
movzbl 0x5(%r15,%r12,1),%esi
movzbl 0x7(%r15,%r12,1),%r9d
mov    %r9d,%edi
and    $0xfffffff0,%edi
shl    $0x4,%edi
or     %esi,%edi
test   %edi,%edi
je     1750 <print_edid+0x5d0>
cmp    $0xfff,%edi
je     1750 <print_edid+0x5d0>
mov    %edx,0xa0(%rsp,%rax,1)
mov    %edi,0xa4(%rsp,%rax,1)
movzbl 0xc(%r15,%r12,1),%r8d
movzbl 0xe(%r15,%r12,1),%ebp
mov    %ebp,%esi
shl    $0x4,%esi
and    $0xf00,%esi
or     %r8d,%esi
cmp    $0xfff,%esi
je     1750 <print_edid+0x5d0>
test   %esi,%esi
je     1750 <print_edid+0x5d0>
movzbl 0xd(%r15,%r12,1),%r8d
and    $0xf,%ebp
shl    $0x8,%ebp
or     %r8d,%ebp
test   %ebp,%ebp
je     1750 <print_edid+0x5d0>
cmp    $0xfff,%ebp
je     1750 <print_edid+0x5d0>
lea    (%rsp,%rax,1),%r8
add    $0xa8,%r8
mov    %esi,(%r8)
mov    %ebp,0x4(%r8)
and    $0xf,%r11d
shl    $0x8,%r11d
or     %ebx,%r11d
movzbl 0x8(%r15,%r12,1),%r8d
movzbl 0xb(%r15,%r12,1),%ebx
lea    0x0(,%rbx,4),%esi
mov    %esi,%ebp
and    $0x300,%ebp
or     %r8d,%ebp
movzbl 0x9(%r15,%r12,1),%r8d
shl    $0x4,%ebx
mov    %ebx,%r10d
and    $0x300,%r10d
or     %r8d,%r10d
movzbl 0x6(%r15,%r12,1),%ecx
mov    %ecx,0x14(%rsp)
and    $0xf,%r9d
shl    $0x8,%r9d
movzbl 0xa(%r15,%r12,1),%ecx
mov    %ecx,%r8d
shr    $0x4,%r8d
and    $0x30,%esi
or     %r8d,%esi
and    $0xf,%ecx
and    $0x30,%ebx
or     %ecx,%ebx
mov    %edx,0xb4(%rsp,%rax,1)
add    %edx,%ebp
mov    %ebp,0xb8(%rsp,%rax,1)
add    %r10d,%ebp
mov    %ebp,0xbc(%rsp,%rax,1)
add    %edx,%r11d
mov    %r11d,0xc0(%rsp,%rax,1)
mov    %edi,0xc8(%rsp,%rax,1)
add    %edi,%esi
mov    %esi,0xcc(%rsp,%rax,1)
add    %ebx,%esi
mov    %esi,0xd0(%rsp,%rax,1)
add    %edi,%r9d
add    0x14(%rsp),%r9d
mov    %r9d,0xd4(%rsp,%rax,1)
movzbl 0x11(%r15,%r12,1),%ecx
mov    %ecx,%edx
not    %edx
test   $0x18,%dl
jne    1750 <print_edid+0x5d0>
xor    %edx,%edx
test   $0x4,%cl
sete   %dl
add    %edx,%edx
add    $0x2b,%edx
mov    %edx,0xc4(%rsp,%rax,1)
xor    %edx,%edx
test   $0x2,%cl
sete   %dl
lea    (%rdx,%rdx,1),%ecx
add    $0x2b,%ecx
mov    %ecx,0xd8(%rsp,%rax,1)
jmp    1750 <print_edid+0x5d0>
nopl   (%rax)
movzbl 0x5(%r15,%r12,1),%eax
movzbl 0x6(%r15,%r12,1),%ecx
mov    %eax,0x330(%rsp)
mov    %ecx,0x334(%rsp)
movzbl 0x7(%r15,%r12,1),%edx
movzbl 0x8(%r15,%r12,1),%esi
lea    -0x1(%rdx),%edi
mov    %edx,0x338(%rsp)
mov    %esi,0x33c(%rsp)
cmp    %sil,%dil
jae    1741 <print_edid+0x5c1>
add    $0xff,%al
cmp    %cl,%al
jb     1750 <print_edid+0x5d0>
jmp    1741 <print_edid+0x5c1>
nop
cmpb   $0x0,0x358(%rsp)
jne    1750 <print_edid+0x5d0>
cmpb   $0x0,0x5(%r15,%r12,1)
je     1750 <print_edid+0x5d0>
add    $0x5,%rdi
mov    $0xd,%esi
xor    %eax,%eax
call   1080 <canon_str@plt>
cltq
movups 0x70(%rax),%xmm0
lea    0x358(%rsp),%rcx
movups %xmm0,0x70(%rcx)
movups 0x60(%rax),%xmm0
movups %xmm0,0x60(%rcx)
movups 0x50(%rax),%xmm0
movups %xmm0,0x50(%rcx)
movups 0x40(%rax),%xmm0
movups %xmm0,0x40(%rcx)
movups (%rax),%xmm0
movups 0x10(%rax),%xmm1
movups 0x20(%rax),%xmm2
movups 0x30(%rax),%xmm3
movups %xmm3,0x30(%rcx)
movups %xmm2,0x20(%rcx)
movups %xmm1,0x10(%rcx)
movups %xmm0,(%rcx)
mov    0x358(%rsp),%cl
test   %cl,%cl
je     1750 <print_edid+0x5d0>
lea    0x359(%rsp),%rax
jmp    1b1f <print_edid+0x99f>
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
add    $0x1,%rax
test   %cl,%cl
je     1750 <print_edid+0x5d0>
cmp    $0x1f,%cl
jg     1b10 <print_edid+0x990>
movb   $0x20,-0x1(%rax)
jmp    1b10 <print_edid+0x990>
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,0x458(%rsp)
jne    1750 <print_edid+0x5d0>
cmpb   $0x0,0x5(%r15,%r12,1)
je     1750 <print_edid+0x5d0>
add    $0x5,%rdi
mov    $0xd,%esi
xor    %eax,%eax
call   1080 <canon_str@plt>
cltq
movups 0x70(%rax),%xmm0
movups %xmm0,0x70(%r14)
movups 0x60(%rax),%xmm0
movups %xmm0,0x60(%r14)
movups 0x50(%rax),%xmm0
movups %xmm0,0x50(%r14)
movups 0x40(%rax),%xmm0
movups %xmm0,0x40(%r14)
movups (%rax),%xmm0
movups 0x10(%rax),%xmm1
movups 0x20(%rax),%xmm2
movups 0x30(%rax),%xmm3
movups %xmm3,0x30(%r14)
movups %xmm2,0x20(%r14)
movups %xmm1,0x10(%r14)
movups %xmm0,(%r14)
mov    0x458(%rsp),%cl
test   %cl,%cl
je     1750 <print_edid+0x5d0>
lea    0x459(%rsp),%rax
jmp    1bcf <print_edid+0xa4f>
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
add    $0x1,%rax
test   %cl,%cl
je     1750 <print_edid+0x5d0>
cmp    $0x1f,%cl
jg     1bc0 <print_edid+0xa40>
movb   $0x20,-0x1(%rax)
jmp    1bc0 <print_edid+0xa40>
mov    0x10(%rsp),%eax
mov    %eax,%ecx
test   %eax,%eax
mov    %rcx,0x18(%rsp)
je     1d78 <print_edid+0xbf8>
mov    0x324(%rsp),%r8d
mov    0x328(%rsp),%r9d
mov    %r8d,%r13d
shl    $0x4,%r13d
mov    %r9d,%eax
shl    $0x4,%eax
mov    %eax,0x14(%rsp)
test   %r8d,%r8d
setne  %al
test   %r9d,%r9d
setne  %dl
and    %al,%dl
mov    %dl,0xb(%rsp)
imul   $0x3c,%rcx,%rsi
xor    %r11d,%r11d
mov    0xc(%rsp),%r15d
jmp    1c4d <print_edid+0xacd>
movq   $0x0,0xa8(%rsp,%r11,1)
nopw   0x0(%rax,%rax,1)
add    $0x3c,%r11
cmp    %r11,%rsi
je     1d7d <print_edid+0xbfd>
mov    0xa0(%rsp,%r11,1),%r14d
test   %r14d,%r14d
je     1c40 <print_edid+0xac0>
mov    0xa4(%rsp,%r11,1),%ebp
test   %ebp,%ebp
je     1c40 <print_edid+0xac0>
mov    %r15d,%eax
shl    $0x4,%rax
mov    %r14d,0x190(%rsp,%rax,1)
mov    %ebp,0x194(%rsp,%rax,1)
movq   $0x3c,0x198(%rsp,%rax,1)
add    $0x1,%r15d
mov    0xa8(%rsp,%r11,1),%r12d
test   %r12d,%r12d
je     1c40 <print_edid+0xac0>
mov    0xac(%rsp,%r11,1),%r10d
test   %r10d,%r10d
je     1c40 <print_edid+0xac0>
shl    $0x4,%ebp
mov    %ebp,%eax
imul   %r12d,%eax
mov    %r10d,%ecx
imul   %r14d,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%edi
mov    $0x10,%ebx
mov    $0x10,%ecx
test   %r8d,%r8d
je     1cd5 <print_edid+0xb55>
mov    %r13d,%eax
xor    %edx,%edx
div    %r12d
mov    %eax,%ecx
test   %r9d,%r9d
je     1ce5 <print_edid+0xb65>
mov    0x14(%rsp),%eax
xor    %edx,%edx
div    %r10d
mov    %eax,%ebx
lea    -0x20(%rdi),%eax
cmp    $0xffffffe9,%eax
jb     1d11 <print_edid+0xb91>
cmp    $0x9,%ecx
jb     1d11 <print_edid+0xb91>
cmp    $0x1f,%ecx
ja     1d11 <print_edid+0xb91>
cmp    $0x9,%ebx
jb     1d11 <print_edid+0xb91>
cmp    $0x1f,%ebx
ja     1d11 <print_edid+0xb91>
cmp    $0x64,%r12d
jb     1d11 <print_edid+0xb91>
cmp    $0x63,%r10d
ja     1c40 <print_edid+0xac0>
cmpb   $0x0,0xb(%rsp)
je     1d53 <print_edid+0xbd3>
imul   %r8d,%ebp
imul   %r9d,%r14d
mov    %ebp,%eax
xor    %edx,%edx
div    %r14d
mov    %eax,%edi
add    $0xfffffff7,%eax
cmp    $0x16,%eax
ja     1d53 <print_edid+0xbd3>
cmp    $0x64,%r8d
jb     1d53 <print_edid+0xbd3>
cmp    $0x64,%r9d
jb     1d53 <print_edid+0xbd3>
mov    %r8d,0xa8(%rsp,%r11,1)
mov    %r9d,0xac(%rsp,%r11,1)
mov    %r9d,%r10d
mov    %r8d,%r12d
add    $0xffffffe0,%edi
cmp    $0xffffffe9,%edi
jb     1c2e <print_edid+0xaae>
cmp    $0x64,%r12d
jb     1c2e <print_edid+0xaae>
cmp    $0x63,%r10d
ja     1c40 <print_edid+0xac0>
jmp    1c2e <print_edid+0xaae>
mov    0xc(%rsp),%r15d
mov    0x31c(%rsp),%edi
xor    %eax,%eax
call   1040 <eisa_vendor@plt>
mov    0x320(%rsp),%edx
lea    0x13af(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x358(%rsp),%al
mov    0x3d8(%rsp),%cl
or     %al,%cl
je     1de6 <print_edid+0xc66>
test   %al,%al
lea    0x13f1(%rip),%rax
lea    0x1383(%rip),%rdx
cmovne %rax,%rdx
lea    0x1388(%rip),%rdi
lea    0x358(%rsp),%rsi
lea    0x3d8(%rsp),%rcx
xor    %eax,%eax
call   1070 <printf@plt>
testb  $0x1,0x318(%rsp)
01
je     1dfe <print_edid+0xc7e>
lea    0x136a(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x32c(%rsp),%esi
lea    0x135c(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmpl   $0x0,0x10(%rsp)
lea    0xa8(%rsp),%rax
lea    0xac(%rsp),%rcx
lea    0x324(%rsp),%rsi
lea    0x328(%rsp),%rdx
cmovne %rcx,%rdx
mov    (%rdx),%edx
cmovne %rax,%rsi
mov    (%rsi),%esi
lea    0x132f(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x330(%rsp),%esi
mov    0x334(%rsp),%edx
mov    0x338(%rsp),%ecx
mov    0x33c(%rsp),%r8d
lea    0x1314(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x1418(%rip),%rdi
call   1050 <puts@plt>
mov    %r15d,0xc(%rsp)
test   %r15d,%r15d
je     1f32 <print_edid+0xdb2>
mov    0xc(%rsp),%r12d
lea    0x19c(%rsp),%rbp
lea    0x1312(%rip),%rbx
lea    0x1295(%rip),%r15
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14d,%r13d
and    $0x3,%r13d
lea    0x12e2(%rip),%rsi
lea    0x12d8(%rip),%rax
cmove  %rax,%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x4(%rbp),%ecx
cmpl   $0x0,0x0(%rbp)
lea    0x12c9(%rip),%r8
cmove  %r15,%r8
lea    0x12b1(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmp    $0x3,%r13d
mov    %r15,%rsi
lea    0x122f(%rip),%rax
cmove  %rax,%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x1,%r14
add    $0x10,%rbp
cmp    %r14,%r12
jne    1ec0 <print_edid+0xd40>
testb  $0x3,0xc(%rsp)
lea    0x1209(%rip),%rax
lea    0x1201(%rip),%rsi
cmove  %rax,%rsi
lea    0x126d(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmpl   $0x0,0x10(%rsp)
mov    0x18(%rsp),%r15
je     20ea <print_edid+0xf6a>
lea    0xd8(%rsp),%r12
lea    0x12bb(%rip),%r13
lea    0x12ea(%rip),%r14
xor    %ebp,%ebp
jmp    1fa1 <print_edid+0xe21>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x3c,%r12
cmp    %rbp,%r15
je     20ea <print_edid+0xf6a>
cmpl   $0x0,-0x18(%r12)
je     1f90 <print_edid+0xe10>
cmpl   $0x0,-0x4(%r12)
je     1f90 <print_edid+0xe10>
lea    0x1216(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1070 <printf@plt>
mov    -0x38(%r12),%esi
mov    -0x34(%r12),%edx
lea    0x1213(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    -0x24(%r12),%esi
mov    -0x20(%r12),%edx
mov    -0x1c(%r12),%ecx
mov    -0x18(%r12),%r8d
mov    %edx,%r9d
sub    %esi,%r9d
mov    %ecx,%r10d
sub    %esi,%r10d
mov    %r8d,%ebx
sub    %esi,%ebx
mov    -0x14(%r12),%r11d
sub    $0x8,%rsp
lea    0x11ed(%rip),%rdi
xor    %eax,%eax
push   %r11
push   %rbx
push   %r10
call   1070 <printf@plt>
add    $0x20,%rsp
mov    -0x10(%r12),%esi
mov    -0xc(%r12),%edx
mov    -0x8(%r12),%ecx
mov    -0x4(%r12),%r8d
mov    %edx,%r9d
sub    %esi,%r9d
mov    %ecx,%r10d
sub    %esi,%r10d
mov    %r8d,%ebx
sub    %esi,%ebx
mov    (%r12),%r11d
sub    $0x8,%rsp
mov    %r13,%rdi
xor    %eax,%eax
push   %r11
push   %rbx
push   %r10
call   1070 <printf@plt>
add    $0x20,%rsp
mov    -0x28(%r12),%edi
mov    -0x18(%r12),%r9d
imul   $0x10624dd3,%rdi,%rsi
shr    $0x26,%rsi
imul   $0x64,%edi,%ebx
imul   $0x10624dd3,%rbx,%rcx
shr    $0x26,%rcx
imul   $0x51eb851f,%rcx,%rax
shr    $0x25,%rax
imul   $0x64,%eax,%eax
sub    %eax,%ecx
mov    %edi,%eax
xor    %edx,%edx
div    %r9d
mov    %eax,%r8d
mov    %ebx,%eax
xor    %edx,%edx
div    %r9d
mov    %eax,%ebx
imul   $0x51eb851f,%rbx,%rax
shr    $0x25,%rax
imul   $0x64,%eax,%eax
sub    %eax,%ebx
imul   $0x3e8,%edi,%eax
xor    %edx,%edx
div    %r9d
xor    %edx,%edx
divl   -0x4(%r12)
sub    $0x8,%rsp
mov    %r14,%rdi
mov    %ecx,%edx
mov    %r8d,%ecx
mov    %ebx,%r8d
mov    %eax,%r9d
xor    %eax,%eax
push   $0x0
call   1070 <printf@plt>
add    $0x10,%rsp
jmp    1f90 <print_edid+0xe10>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x4d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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