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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ arp_dump(unsigned char *, int);
int /*<<< orphan*/ data_dump(unsigned char *, int, int);
char *decode_type(int);
int /*<<< orphan*/ flexnet_dump(unsigned char *, int, int);
int ftype(unsigned char *, int *, int *, int *, int *, int);
int /*<<< orphan*/ ip_dump(unsigned char *, int, int);
int /*<<< orphan*/ lprintf(int, char *, ...);
int /*<<< orphan*/ netrom_dump(unsigned char *, int, int);
char *pax25(char *, unsigned char *);
int /*<<< orphan*/ rose_dump(unsigned char *, int, int);
int /*<<< orphan*/ sprintf(char *, char *, ...);
int /*<<< orphan*/ strtok(char *, char *);
void ax25_dump(unsigned char *data, int length, int hexdump) {
  char tmp[15];
  char ext[40];
  int ctlen, nr = 0, ns = 0, pf, pid, seg, type, end, cmdrsp, extseq, paclen;
  char *dama;
  if (length < 8) {
    lprintf(1, "AX25: bad header!\n");
    return;
  }
  if (data[1] & 0x01) {
    lprintf(6, "AX25: ");
    tmp[6] = tmp[7] = extseq = 0;
    tmp[0] = ' ' + (data[2] >> 2);
    tmp[1] = ' ' + ((data[2] << 4) & 0x30) + (data[3] >> 4);
    tmp[2] = ' ' + ((data[3] << 2) & 0x3c) + (data[4] >> 6);
    tmp[3] = ' ' + (data[4] & 0x3f);
    tmp[4] = ' ' + (data[5] >> 2);
    tmp[5] = ' ' + ((data[5] << 4) & 0x30) + (data[6] >> 4);
    if (data[6] & 0xf)
      sprintf(tmp + 7, "-%d", data[6] & 0xf);
    lprintf(8, "%d->%s%s", (data[0] << 6) | ((data[1] >> 2) & 0x3f),
            strtok(tmp, " "), tmp + 7);
    cmdrsp = (data[1] & 2) ? 1 : 2;
    dama = "";
    data += 7;
    length -= 7;
  } else {
    if (length < (7 + 7 + 1)) {
      lprintf(1, "AX25: bad header!\n");
      return;
    }
    if ((data[7 + 6] & 0x40) == 0x40) {
      extseq = 0;
      lprintf(6, "AX25: ");
    } else {
      extseq = 1;
      lprintf(6, "EAX25: ");
    }
    if ((data[7 + 6] & 0x20) == 0x20)
      dama = "";
    else
      dama = " [DAMA]";
    lprintf(8, "%s", pax25(tmp, data + 7));
    lprintf(8, "->%s", pax25(tmp, data));
    cmdrsp = 0;
    if ((data[6] & 0x80) && !(data[7 + 6] & 0x80))
      cmdrsp = 1;
    if ((data[7 + 6] & 0x80) && !(data[6] & 0x80))
      cmdrsp = 2;
    end = (data[7 + 6] & 0x01);
    data += (7 + 7);
    length -= (7 + 7);
    if (!end) {
      lprintf(7, " v");
      while (!end) {
        lprintf(8, " %s%s", pax25(tmp, data), (data[6] & 0x80) ? "*" : "");
        end = (data[6] & 0x01);
        data += 7;
        length -= 7;
      }
    }
  }
  if (length == 0)
    return;
  paclen = length - 2;
  ctlen = ftype(data, &type, &ns, &nr, &pf, extseq);
  data += ctlen;
  length -= ctlen;
  lprintf(7, " <%s", decode_type(type));
  switch (cmdrsp) {
  case 1:
    lprintf(7, " C");
    if (pf)
      lprintf(7, " P");
    break;
  case 2:
    lprintf(7, " R");
    if (pf)
      lprintf(7, " F");
    break;
  default:
    break;
  }
  if (type == 0x00)
    lprintf(7, " S%d", ns);
  if ((type & 0x3) != 0x03)
    lprintf(7, " R%d", nr);
  lprintf(7, ">");
  if (type == 0x00 || type == 0x03) {
    if (length > 0) {
      pid = *data++;
      length--;
      if (pid == 0x08) {
        seg = *data++;
        length--;
        lprintf(7, "%s remain %u", seg & 0x80 ? " First seg;" : "", seg & 0x7F);
        if (seg & 0x80) {
          pid = *data++;
          length--;
        }
      }
      sprintf(ext, "%s (%d)", dama, paclen);
      switch (pid) {
      case 0x08:
        lprintf(7, "%s\n", ext);
        data_dump(data, length, hexdump);
        break;
      case 0xCD:
        lprintf(7, " pid=ARP%s\n", ext);
        arp_dump(data, length);
        break;
      case 0xCF:
        lprintf(7, " pid=NET/ROM%s\n", ext);
        netrom_dump(data, length, hexdump);
        break;
      case 0xCC:
        lprintf(7, " pid=IP%s\n", ext);
        ip_dump(data, length, hexdump);
        break;
      case 0x01:
        lprintf(7, " pid=X.25%s\n", ext);
        rose_dump(data, length, hexdump);
        break;
      case 0xC3:
        lprintf(7, " pid=TEXNET%s\n", ext);
        data_dump(data, length, hexdump);
        break;
      case 0xCE:
        lprintf(7, " pid=FLEXNET%s\n", ext);
        flexnet_dump(data, length, hexdump);
        break;
      case 0xF0:
        lprintf(7, " pid=Text%s\n", ext);
        data_dump(data, length, hexdump);
        break;
      default:
        lprintf(7, " pid=0x%x%s\n", pid, ext);
        data_dump(data, length, hexdump);
        break;
      }
    }
  } else if (type == 0x87 && length >= 3) {
    lprintf(7, ": %02X", data[0]);
    lprintf(7, " Vr = %d Vs = %d", (data[1] >> 5) & 7, (data[1] >> 1) & 7);
    if (data[2] & 1)
      lprintf(1, " Invalid control field");
    if (data[2] & 2)
      lprintf(1, " Illegal I-field");
    if (data[2] & 4)
      lprintf(1, " Too-long I-field");
    if (data[2] & 8)
      lprintf(1, " Invalid seq number");
    lprintf(7, "%s\n", dama);
  } else if ((type == 0x2F || type == 0x63) && length >= 2) {
    lprintf(7, " [%d]%s\n", (data[0] << 8) | data[1], dama);
  } else {
    lprintf(7, "%s\n", dama);
  }
}


x86 assembly (clang, -O0):
<ax25_dump>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    1205 <ax25_dump+0x45>
mov    $0x1,%edi
lea    0xe07(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    1bdc <ax25_dump+0xa1c>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     139f <ax25_dump+0x1df>
mov    $0x6,%edi
lea    0xdfc(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
movl   $0x0,-0x78(%rbp)
movb   $0x0,-0x18(%rbp)
movb   $0x0,-0x19(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
sar    $0x2,%eax
add    $0x20,%eax
mov    %al,-0x1f(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x4,%eax
and    $0x30,%eax
add    $0x20,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
sar    $0x4,%ecx
add    %ecx,%eax
mov    %al,-0x1e(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x2,%eax
and    $0x3c,%eax
add    $0x20,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
sar    $0x6,%ecx
add    %ecx,%eax
mov    %al,-0x1d(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x3f,%eax
add    $0x20,%eax
mov    %al,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x5(%rax),%eax
sar    $0x2,%eax
add    $0x20,%eax
mov    %al,-0x1b(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x5(%rax),%eax
shl    $0x4,%eax
and    $0x30,%eax
add    $0x20,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
sar    $0x4,%ecx
add    %ecx,%eax
mov    %al,-0x1a(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0xf,%eax
cmp    $0x0,%eax
je     1306 <ax25_dump+0x146>
lea    -0x1f(%rbp),%rdi
add    $0x7,%rdi
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%edx
and    $0xf,%edx
lea    0xd14(%rip),%rsi
mov    $0x0,%al
call   10d0 <sprintf@plt>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
shl    $0x6,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sar    $0x2,%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x8c(%rbp)
lea    -0x1f(%rbp),%rdi
lea    0xcf5(%rip),%rsi
call   10b0 <strtok@plt>
mov    -0x8c(%rbp),%edx
mov    %eax,%ecx
lea    -0x1f(%rbp),%r8
add    $0x7,%r8
mov    $0x8,%edi
lea    0xcc5(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%edx
and    $0x2,%edx
mov    $0x2,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x74(%rbp)
lea    0xc94(%rip),%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
add    $0x7,%rax
mov    %rax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xc(%rbp)
jmp    15c8 <ax25_dump+0x408>
cmpl   $0xf,-0xc(%rbp)
jge    13c1 <ax25_dump+0x201>
mov    $0x1,%edi
lea    0xc4b(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    1bdc <ax25_dump+0xa1c>
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%eax
and    $0x40,%eax
cmp    $0x40,%eax
jne    13f4 <ax25_dump+0x234>
movl   $0x0,-0x78(%rbp)
mov    $0x6,%edi
lea    0xc39(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    140e <ax25_dump+0x24e>
movl   $0x1,-0x78(%rbp)
mov    $0x6,%edi
lea    0xc19(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%eax
and    $0x20,%eax
cmp    $0x20,%eax
jne    1435 <ax25_dump+0x275>
lea    0xbe9(%rip),%rax
mov    %rax,-0x88(%rbp)
jmp    1443 <ax25_dump+0x283>
lea    0xbec(%rip),%rax
mov    %rax,-0x88(%rbp)
lea    -0x1f(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x7,%rsi
call   1060 <pax25@plt>
mov    %rax,%rdx
mov    $0x8,%edi
lea    0xbdf(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
lea    -0x1f(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1060 <pax25@plt>
mov    %rax,%rdx
mov    $0x8,%edi
lea    0xbaa(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
movl   $0x0,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     14c7 <ax25_dump+0x307>
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
jne    14c7 <ax25_dump+0x307>
movl   $0x1,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     14fa <ax25_dump+0x33a>
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
jne    14fa <ax25_dump+0x33a>
movl   $0x2,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%eax
and    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
add    $0xe,%rax
mov    %rax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
sub    $0xe,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0x70(%rbp)
jne    15c3 <ax25_dump+0x403>
mov    $0x7,%edi
lea    0xb02(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
cmpl   $0x0,-0x70(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1550 <ax25_dump+0x390>
jmp    15be <ax25_dump+0x3fe>
lea    -0x1f(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1060 <pax25@plt>
mov    %rax,%rdx
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%esi
and    $0x80,%esi
lea    0xa9d(%rip),%rcx
lea    0xac2(%rip),%rax
cmp    $0x0,%esi
cmovne %rax,%rcx
mov    $0x8,%edi
lea    0xaa9(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
add    $0x7,%rax
mov    %rax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xc(%rbp)
jmp    153a <ax25_dump+0x37a>
jmp    15c3 <ax25_dump+0x403>
jmp    15c8 <ax25_dump+0x408>
cmpl   $0x0,-0xc(%rbp)
jne    15d7 <ax25_dump+0x417>
jmp    1bdc <ax25_dump+0xa1c>
mov    -0xc(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x78(%rbp),%r9d
lea    -0x6c(%rbp),%rsi
lea    -0x5c(%rbp),%rdx
lea    -0x58(%rbp),%rcx
lea    -0x60(%rbp),%r8
call   1090 <ftype@plt>
mov    %eax,-0x54(%rbp)
movslq -0x54(%rbp),%rcx
mov    -0x8(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0xc(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc(%rbp)
mov    -0x6c(%rbp),%edi
call   1040 <decode_type@plt>
mov    %rax,%rdx
lea    0xa14(%rip),%rsi
xor    %eax,%eax
mov    $0x7,%edi
call   10e0 <lprintf@plt>
mov    -0x74(%rbp),%eax
mov    %eax,-0x90(%rbp)
sub    $0x1,%eax
je     1663 <ax25_dump+0x4a3>
jmp    164f <ax25_dump+0x48f>
mov    -0x90(%rbp),%eax
sub    $0x2,%eax
je     1698 <ax25_dump+0x4d8>
jmp    16cd <ax25_dump+0x50d>
mov    $0x7,%edi
lea    0x9d6(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
cmpl   $0x0,-0x60(%rbp)
je     1693 <ax25_dump+0x4d3>
mov    $0x7,%edi
lea    0x9bc(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    16d2 <ax25_dump+0x512>
mov    $0x7,%edi
lea    0x9a7(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
cmpl   $0x0,-0x60(%rbp)
je     16c8 <ax25_dump+0x508>
mov    $0x7,%edi
lea    0x98d(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    16d2 <ax25_dump+0x512>
jmp    16d2 <ax25_dump+0x512>
cmpl   $0x0,-0x6c(%rbp)
jne    16f2 <ax25_dump+0x532>
mov    -0x5c(%rbp),%edx
mov    $0x7,%edi
lea    0x966(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x6c(%rbp),%eax
and    $0x3,%eax
cmp    $0x3,%eax
je     1717 <ax25_dump+0x557>
mov    -0x58(%rbp),%edx
mov    $0x7,%edi
lea    0x946(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    $0x7,%edi
lea    0x938(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
cmpl   $0x0,-0x6c(%rbp)
je     173e <ax25_dump+0x57e>
cmpl   $0x3,-0x6c(%rbp)
jne    1a4c <ax25_dump+0x88c>
cmpl   $0x0,-0xc(%rbp)
jle    1a47 <ax25_dump+0x887>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x8,-0x64(%rbp)
jne    17f9 <ax25_dump+0x639>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x68(%rbp),%ecx
and    $0x80,%ecx
lea    0x874(%rip),%rdx
lea    0x8c5(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
mov    -0x68(%rbp),%ecx
and    $0x7f,%ecx
mov    $0x7,%edi
lea    0x89f(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x68(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     17f4 <ax25_dump+0x634>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    17f9 <ax25_dump+0x639>
mov    -0x88(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
lea    0x86c(%rip),%rsi
xor    %eax,%eax
lea    -0x50(%rbp),%rdi
call   10d0 <sprintf@plt>
mov    -0x64(%rbp),%eax
mov    %eax,-0x94(%rbp)
sub    $0x1,%eax
je     196d <ax25_dump+0x7ad>
jmp    182c <ax25_dump+0x66c>
mov    -0x94(%rbp),%eax
sub    $0x8,%eax
je     18c4 <ax25_dump+0x704>
jmp    1840 <ax25_dump+0x680>
mov    -0x94(%rbp),%eax
sub    $0xc3,%eax
je     1998 <ax25_dump+0x7d8>
jmp    1856 <ax25_dump+0x696>
mov    -0x94(%rbp),%eax
sub    $0xcc,%eax
je     1942 <ax25_dump+0x782>
jmp    186c <ax25_dump+0x6ac>
mov    -0x94(%rbp),%eax
sub    $0xcd,%eax
je     18ef <ax25_dump+0x72f>
jmp    1882 <ax25_dump+0x6c2>
mov    -0x94(%rbp),%eax
sub    $0xce,%eax
je     19c3 <ax25_dump+0x803>
jmp    1898 <ax25_dump+0x6d8>
mov    -0x94(%rbp),%eax
sub    $0xcf,%eax
je     1917 <ax25_dump+0x757>
jmp    18ae <ax25_dump+0x6ee>
mov    -0x94(%rbp),%eax
sub    $0xf0,%eax
je     19ee <ax25_dump+0x82e>
jmp    1a19 <ax25_dump+0x859>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x7da(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1050 <data_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x77f(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <arp_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x763(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   10a0 <netrom_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x748(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   10c0 <ip_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x728(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1080 <rose_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x70a(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1050 <data_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x6ee(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1070 <flexnet_dump@plt>
jmp    1a42 <ax25_dump+0x882>
lea    -0x50(%rbp),%rdx
mov    $0x7,%edi
lea    0x6d3(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1050 <data_dump@plt>
jmp    1a42 <ax25_dump+0x882>
mov    -0x64(%rbp),%edx
lea    -0x50(%rbp),%rcx
mov    $0x7,%edi
lea    0x6b2(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1050 <data_dump@plt>
jmp    1a47 <ax25_dump+0x887>
jmp    1bdc <ax25_dump+0xa1c>
cmpl   $0x87,-0x6c(%rbp)
jne    1b67 <ax25_dump+0x9a7>
cmpl   $0x3,-0xc(%rbp)
jl     1b67 <ax25_dump+0x9a7>
mov    -0x8(%rbp),%rax
movzbl (%rax),%edx
mov    $0x7,%edi
lea    0x675(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%edx
sar    $0x5,%edx
and    $0x7,%edx
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%ecx
sar    $0x1,%ecx
and    $0x7,%ecx
mov    $0x7,%edi
lea    0x64d(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1ad3 <ax25_dump+0x913>
mov    $0x1,%edi
lea    0x637(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1afa <ax25_dump+0x93a>
mov    $0x1,%edi
lea    0x627(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1b21 <ax25_dump+0x961>
mov    $0x1,%edi
lea    0x611(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1b48 <ax25_dump+0x988>
mov    $0x1,%edi
lea    0x5fc(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
mov    -0x88(%rbp),%rdx
mov    $0x7,%edi
lea    0x553(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    1bd7 <ax25_dump+0xa17>
cmpl   $0x2f,-0x6c(%rbp)
je     1b7b <ax25_dump+0x9bb>
cmpl   $0x63,-0x6c(%rbp)
jne    1bb8 <ax25_dump+0x9f8>
cmpl   $0x2,-0xc(%rbp)
jl     1bb8 <ax25_dump+0x9f8>
mov    -0x8(%rbp),%rax
movzbl (%rax),%edx
shl    $0x8,%edx
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
or     %eax,%edx
mov    -0x88(%rbp),%rcx
mov    $0x7,%edi
lea    0x5a5(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    1bd2 <ax25_dump+0xa12>
mov    -0x88(%rbp),%rdx
mov    $0x7,%edi
lea    0x4e3(%rip),%rsi
mov    $0x0,%al
call   10e0 <lprintf@plt>
jmp    1bd7 <ax25_dump+0xa17>
jmp    1bdc <ax25_dump+0xa1c>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ax25_dump>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x18(%rsp)
cmp    $0x7,%esi
jg     1204 <ax25_dump+0x44>
lea    0xf2e(%rip),%rsi
mov    $0x1,%edi
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10e0 <lprintf@plt>
mov    %edx,%ebx
mov    %esi,%ebp
mov    %rdi,%r14
testb  $0x1,0x1(%rdi)
jne    137b <ax25_dump+0x1bb>
cmp    $0xe,%ebp
jbe    11e3 <ax25_dump+0x23>
mov    0xd(%r14),%cl
and    $0x40,%cl
lea    0xf10(%rip),%rax
lea    0xf0a(%rip),%rsi
cmove  %rax,%rsi
shr    $0x6,%cl
xor    $0x1,%cl
mov    %ecx,0x10(%rsp)
xor    %r12d,%r12d
mov    $0x6,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
testb  $0x20,0xd(%r14)
lea    0xee8(%rip),%r13
lea    0xecb(%rip),%rax
cmovne %rax,%r13
lea    0x7(%r14),%rsi
lea    0x21(%rsp),%r15
mov    %r15,%rdi
call   1060 <pax25@plt>
lea    0xedf(%rip),%rsi
mov    $0x8,%edi
mov    %rax,%rdx
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r15,%rdi
mov    %r14,%rsi
call   1060 <pax25@plt>
lea    0xeac(%rip),%rsi
mov    $0x8,%edi
mov    %rax,%rdx
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0xd(%r14),%al
mov    %eax,%ecx
not    %cl
shr    $0x7,%cl
cmpb   $0x0,0x6(%r14)
movzbl %cl,%edx
mov    $0x2,%ecx
cmovs  %edx,%ecx
cmovns %r12d,%edx
test   %al,%al
cmovs  %ecx,%edx
mov    %edx,0xc(%rsp)
add    $0xe,%r14
add    $0xfffffff2,%ebp
test   $0x1,%al
mov    %ebx,0x8(%rsp)
jne    168c <ax25_dump+0x4cc>
mov    %r13,0x60(%rsp)
lea    0xe5b(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
lea    0x21(%rsp),%r12
lea    0xe4c(%rip),%r15
lea    0xe3f(%rip),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rbx
mov    %r12,%rdi
mov    %r14,%rsi
call   1060 <pax25@plt>
cmpb   $0x0,0x6(%r14)
mov    %r15,%rcx
lea    0xded(%rip),%rdx
cmovns %rdx,%rcx
mov    $0x8,%edi
mov    %r13,%rsi
mov    %rax,%rdx
xor    %eax,%eax
call   10e0 <lprintf@plt>
add    $0x7,%r14
add    $0xfffffff9,%ebp
testb  $0x1,0x6(%rbx)
je     1320 <ax25_dump+0x160>
test   %ebp,%ebp
mov    0x60(%rsp),%r13
mov    0x10(%rsp),%r15d
mov    0xc(%rsp),%ebx
jne    1482 <ax25_dump+0x2c2>
jmp    1877 <ax25_dump+0x6b7>
mov    %ebx,0x8(%rsp)
lea    0xdb3(%rip),%rsi
mov    $0x6,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
lea    0x28(%rsp),%r12
movw   $0x0,0x27(%rsp)
mov    0x2(%r14),%al
mov    %eax,%ecx
shr    $0x2,%cl
add    $0x20,%cl
mov    %cl,0x21(%rsp)
shl    $0x4,%al
mov    0x3(%r14),%cl
mov    %ecx,%edx
shr    $0x4,%dl
or     %al,%dl
and    $0x3f,%dl
add    $0x20,%dl
mov    %dl,0x22(%rsp)
shl    $0x2,%cl
mov    0x4(%r14),%al
mov    %eax,%edx
shr    $0x6,%dl
or     %cl,%dl
and    $0x3f,%dl
add    $0x20,%dl
mov    %dl,0x23(%rsp)
and    $0x3f,%al
add    $0x20,%al
mov    %al,0x24(%rsp)
mov    0x5(%r14),%al
mov    %eax,%ecx
shr    $0x2,%cl
add    $0x20,%cl
mov    %cl,0x25(%rsp)
shl    $0x4,%al
movzbl 0x6(%r14),%edx
mov    %edx,%ecx
shr    $0x4,%cl
or     %al,%cl
and    $0x3f,%cl
add    $0x20,%cl
mov    %cl,0x26(%rsp)
and    $0xf,%edx
je     1425 <ax25_dump+0x265>
lea    0xd10(%rip),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   10d0 <sprintf@plt>
movzbl (%r14),%eax
shl    $0x6,%eax
movzbl 0x1(%r14),%ebx
shr    $0x2,%ebx
or     %eax,%ebx
lea    0xd01(%rip),%rsi
lea    0x21(%rsp),%rdi
call   10b0 <strtok@plt>
lea    0xce1(%rip),%rsi
xor    %r15d,%r15d
mov    $0x8,%edi
mov    %ebx,%edx
mov    %eax,%ecx
mov    %r12,%r8
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x1(%r14),%al
and    $0x2,%al
add    $0x7,%r14
add    $0xfffffff9,%ebp
cmp    $0x1,%al
mov    $0x1,%ebx
adc    $0x0,%ebx
lea    0xca8(%rip),%r13
movzbl %r15b,%r9d
lea    0x4(%rsp),%rsi
lea    0x18(%rsp),%rdx
lea    0x1c(%rsp),%rcx
lea    0x14(%rsp),%r8
mov    %r14,%rdi
call   1090 <ftype@plt>
mov    %eax,%r12d
mov    0x4(%rsp),%edi
call   1040 <decode_type@plt>
lea    0xca3(%rip),%rsi
mov    $0x7,%edi
mov    %rax,%rdx
xor    %eax,%eax
call   10e0 <lprintf@plt>
cmp    $0x2,%ebx
je     14f1 <ax25_dump+0x331>
cmp    $0x1,%ebx
jne    151e <ax25_dump+0x35e>
lea    0xc88(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
cmpl   $0x0,0x14(%rsp)
je     151e <ax25_dump+0x35e>
lea    0xc71(%rip),%rsi
jmp    1512 <ax25_dump+0x352>
lea    0xc6b(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
cmpl   $0x0,0x14(%rsp)
je     151e <ax25_dump+0x35e>
lea    0xc54(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jne    1541 <ax25_dump+0x381>
mov    0x18(%rsp),%edx
lea    0xc38(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x4(%rsp),%eax
movslq %r12d,%rbx
not    %eax
test   $0x3,%al
je     1561 <ax25_dump+0x3a1>
mov    0x1c(%rsp),%edx
lea    0xc19(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
add    %rbx,%r14
mov    %ebp,%r12d
sub    %ebx,%r12d
lea    0xc02(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x4(%rsp),%eax
cmp    $0x3,%eax
je     158e <ax25_dump+0x3ce>
test   %eax,%eax
jne    160e <ax25_dump+0x44e>
test   %r12d,%r12d
jle    1877 <ax25_dump+0x6b7>
add    $0xfffffffe,%ebp
mov    (%r14),%bl
add    $0x1,%r14
cmp    $0x8,%bl
jne    1681 <ax25_dump+0x4c1>
movzbl (%r14),%ebx
add    $0x1,%r14
test   $0x80,%bl
lea    0xb6e(%rip),%rax
lea    0xbbf(%rip),%rdx
cmove  %rax,%rdx
mov    %ebx,%ecx
and    $0x7f,%ecx
lea    0xba2(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
test   $0x80,%bl
mov    0x8(%rsp),%r15d
jne    16dc <ax25_dump+0x51c>
add    $0xfffffffe,%r12d
lea    0xb96(%rip),%rsi
lea    0x30(%rsp),%rdi
mov    %r13,%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   10d0 <sprintf@plt>
jmp    1729 <ax25_dump+0x569>
cmp    $0x87,%eax
jne    169a <ax25_dump+0x4da>
cmp    $0x3,%r12d
jl     169a <ax25_dump+0x4da>
movzbl (%r14),%edx
lea    0xbd9(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
movzbl 0x1(%r14),%ecx
mov    %ecx,%edx
shr    $0x5,%edx
shr    %ecx
and    $0x7,%ecx
lea    0xbbe(%rip),%rsi
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x2(%r14),%al
test   $0x1,%al
jne    1735 <ax25_dump+0x575>
test   $0x2,%al
jne    1754 <ax25_dump+0x594>
test   $0x4,%al
jne    1773 <ax25_dump+0x5b3>
test   $0x8,%al
jne    178e <ax25_dump+0x5ce>
jmp    17a1 <ax25_dump+0x5e1>
add    $0xffffffff,%r12d
mov    0x8(%rsp),%r15d
jmp    16e7 <ax25_dump+0x527>
mov    0x10(%rsp),%r15d
mov    0xc(%rsp),%ebx
jmp    1482 <ax25_dump+0x2c2>
cmp    $0x2f,%eax
setne  %cl
cmp    $0x63,%eax
setne  %al
test   %al,%cl
jne    17a1 <ax25_dump+0x5e1>
cmp    $0x2,%r12d
jl     17a1 <ax25_dump+0x5e1>
movzwl (%r14),%edx
shl    $0x10,%edx
bswap  %edx
lea    0xba1(%rip),%rsi
mov    $0x7,%edi
mov    %r13,%rcx
xor    %eax,%eax
call   10e0 <lprintf@plt>
jmp    1877 <ax25_dump+0x6b7>
mov    (%r14),%bl
add    $0x1,%r14
add    $0xfffffffd,%r12d
lea    0xaa0(%rip),%rsi
lea    0x30(%rsp),%rdi
mov    %r13,%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   10d0 <sprintf@plt>
lea    0x3d(%rbx),%eax
cmp    $0x45,%al
ja     17bc <ax25_dump+0x5fc>
movzbl %al,%eax
lea    0x8ec(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0xaa6(%rip),%rsi
jmp    1858 <ax25_dump+0x698>
lea    0xa96(%rip),%rsi
jmp    1858 <ax25_dump+0x698>
lea    0xadf(%rip),%rsi
mov    $0x1,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x2(%r14),%al
test   $0x2,%al
je     166c <ax25_dump+0x4ac>
lea    0xad7(%rip),%rsi
mov    $0x1,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x2(%r14),%al
test   $0x4,%al
je     1674 <ax25_dump+0x4b4>
lea    0xac9(%rip),%rsi
mov    $0x1,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    0x2(%r14),%al
test   $0x8,%al
je     17a1 <ax25_dump+0x5e1>
lea    0xac0(%rip),%rsi
mov    $0x1,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
lea    0xa1e(%rip),%rsi
mov    $0x7,%edi
mov    %r13,%rdx
xor    %eax,%eax
call   10e0 <lprintf@plt>
jmp    1877 <ax25_dump+0x6b7>
movzbl %bl,%edx
lea    0xa30(%rip),%rsi
lea    0x30(%rsp),%rcx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
jmp    1869 <ax25_dump+0x6a9>
lea    0x9cf(%rip),%rsi
lea    0x30(%rsp),%rdx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15d,%edx
call   10c0 <ip_dump@plt>
jmp    1877 <ax25_dump+0x6b7>
lea    0x98b(%rip),%rsi
lea    0x30(%rsp),%rdx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r14,%rdi
mov    %r12d,%esi
call   1030 <arp_dump@plt>
jmp    1877 <ax25_dump+0x6b7>
lea    0x972(%rip),%rsi
lea    0x30(%rsp),%rdx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15d,%edx
call   10a0 <netrom_dump@plt>
jmp    1877 <ax25_dump+0x6b7>
lea    0x991(%rip),%rsi
lea    0x30(%rsp),%rdx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15d,%edx
call   1050 <data_dump@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x930(%rip),%rsi
lea    0x30(%rsp),%rdx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15d,%edx
call   1080 <rose_dump@plt>
jmp    1877 <ax25_dump+0x6b7>
lea    0x924(%rip),%rsi
lea    0x30(%rsp),%rdx
mov    $0x7,%edi
xor    %eax,%eax
call   10e0 <lprintf@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r15d,%edx
call   1070 <flexnet_dump@plt>
jmp    1877 <ax25_dump+0x6b7>

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

LLVM IR (-O2):
@.str = [19 x i8] c"AX25: bad header!\0A\00"
@.str.1 = [7 x i8] c"AX25: \00"
@.str.2 = [4 x i8] c"-%d\00"
@.str.3 = [9 x i8] c"%d->%s%s\00"
@.str.4 = [2 x i8] c" \00"
@.str.5 = [1 x i8] zeroinitializer
@.str.6 = [8 x i8] c"EAX25: \00"
@.str.7 = [8 x i8] c" [DAMA]\00"
@.str.8 = [3 x i8] c"%s\00"
@.str.9 = [5 x i8] c"->%s\00"
@.str.10 = [3 x i8] c" v\00"
@.str.11 = [6 x i8] c" %s%s\00"
@.str.12 = [2 x i8] c"*\00"
@.str.13 = [5 x i8] c" <%s\00"
@.str.14 = [3 x i8] c" C\00"
@.str.15 = [3 x i8] c" P\00"
@.str.16 = [3 x i8] c" R\00"
@.str.17 = [3 x i8] c" F\00"
@.str.18 = [5 x i8] c" S%d\00"
@.str.19 = [5 x i8] c" R%d\00"
@.str.20 = [2 x i8] c">\00"
@.str.21 = [13 x i8] c"%s remain %u\00"
@.str.22 = [12 x i8] c" First seg;\00"
@.str.23 = [8 x i8] c"%s (%d)\00"
@.str.24 = [4 x i8] c"%s\0A\00"
@.str.25 = [12 x i8] c" pid=ARP%s\0A\00"
@.str.26 = [16 x i8] c" pid=NET/ROM%s\0A\00"
@.str.27 = [11 x i8] c" pid=IP%s\0A\00"
@.str.28 = [13 x i8] c" pid=X.25%s\0A\00"
@.str.29 = [15 x i8] c" pid=TEXNET%s\0A\00"
@.str.30 = [16 x i8] c" pid=FLEXNET%s\0A\00"
@.str.31 = [13 x i8] c" pid=Text%s\0A\00"
@.str.32 = [13 x i8] c" pid=0x%x%s\0A\00"
@.str.33 = [7 x i8] c": %02X\00"
@.str.34 = [17 x i8] c" Vr = %d Vs = %d\00"
@.str.35 = [23 x i8] c" Invalid control field\00"
@.str.36 = [17 x i8] c" Illegal I-field\00"
@.str.37 = [18 x i8] c" Too-long I-field\00"
@.str.38 = [20 x i8] c" Invalid seq number\00"
@.str.39 = [9 x i8] c" [%d]%s\0A\00"
define void @ax25_dump(i8* %0, i32 %1, i32 %2) {
%4 = alloca [15 x i8]
%5 = alloca [40 x i8]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 0
%11 = getelementptr inbounds [40 x i8], [40 x i8]* %5, i64 0, i64 0
%12 = bitcast i32* %6 to i8*
store i32 0, i32* %6
%13 = bitcast i32* %7 to i8*
store i32 0, i32* %7
%14 = bitcast i32* %8 to i8*
%15 = bitcast i32* %9 to i8*
%16 = icmp slt i32 %1, 8
br i1 %16, label %17, label %19
17: ; preds = %3
%18 = tail call i32 (i32, i8*, ...) @lprintf(i32 1, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
br label %302
19: ; preds = %3
%20 = getelementptr inbounds i8, i8* %0, i64 1
%21 = load i8, i8* %20
%22 = and i8 %21, 1
%23 = icmp eq i8 %22, 0
br i1 %23, label %85, label %24
24: ; preds = %19
%25 = tail call i32 (i32, i8*, ...) @lprintf(i32 6, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%26 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 7
store i8 0, i8* %26
%27 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 6
store i8 0, i8* %27
%28 = getelementptr inbounds i8, i8* %0, i64 2
%29 = load i8, i8* %28
%30 = lshr i8 %29, 2
%31 = add nuw nsw i8 %30, 32
store i8 %31, i8* %10
%32 = shl i8 %29, 4
%33 = and i8 %32, 48
%34 = add nuw nsw i8 %33, 32
%35 = getelementptr inbounds i8, i8* %0, i64 3
%36 = load i8, i8* %35
%37 = lshr i8 %36, 4
%38 = or i8 %34, %37
%39 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 1
store i8 %38, i8* %39
%40 = shl i8 %36, 2
%41 = and i8 %40, 60
%42 = add nuw nsw i8 %41, 32
%43 = getelementptr inbounds i8, i8* %0, i64 4
%44 = load i8, i8* %43
%45 = lshr i8 %44, 6
%46 = or i8 %42, %45
%47 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 2
store i8 %46, i8* %47
%48 = and i8 %44, 63
%49 = add nuw nsw i8 %48, 32
%50 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 3
store i8 %49, i8* %50
%51 = getelementptr inbounds i8, i8* %0, i64 5
%52 = load i8, i8* %51
%53 = lshr i8 %52, 2
%54 = add nuw nsw i8 %53, 32
%55 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 4
store i8 %54, i8* %55
%56 = shl i8 %52, 4
%57 = and i8 %56, 48
%58 = add nuw nsw i8 %57, 32
%59 = getelementptr inbounds i8, i8* %0, i64 6
%60 = load i8, i8* %59
%61 = lshr i8 %60, 4
%62 = or i8 %58, %61
%63 = getelementptr inbounds [15 x i8], [15 x i8]* %4, i64 0, i64 5
store i8 %62, i8* %63
%64 = and i8 %60, 15
%65 = icmp eq i8 %64, 0
br i1 %65, label %69, label %66
66: ; preds = %24
%67 = zext i8 %64 to i32
%68 = call i32 (i8*, i8*, ...) @sprintf(i8* %26, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %67)
br label %69
69: ; preds = %66, %24
%70 = load i8, i8* %0
%71 = zext i8 %70 to i32
%72 = shl nuw nsw i32 %71, 6
%73 = load i8, i8* %20
%74 = lshr i8 %73, 2
%75 = zext i8 %74 to i32
%76 = or i32 %72, %75
%77 = call i32 @strtok(i8* %10, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%78 = call i32 (i32, i8*, ...) @lprintf(i32 8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0), i32 %76, i32 %77, i8* %26)
%79 = load i8, i8* %20
%80 = and i8 %79, 2
%81 = icmp eq i8 %80, 0
%82 = getelementptr inbounds i8, i8* %0, i64 7
%83 = add nsw i32 %1, -7
%84 = select i1 %81, i32 2, i32 1
br label %140
85: ; preds = %19
%86 = icmp ult i32 %1, 15
br i1 %86, label %87, label %89
87: ; preds = %85
%88 = tail call i32 (i32, i8*, ...) @lprintf(i32 1, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
br label %302
89: ; preds = %85
%90 = getelementptr inbounds i8, i8* %0, i64 13
%91 = load i8, i8* %90
%92 = and i8 %91, 64
%93 = icmp eq i8 %92, 0
%94 = select i1 %93, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0)
%95 = lshr exact i8 %92, 6
%96 = xor i8 %95, 1
%97 = tail call i32 (i32, i8*, ...) @lprintf(i32 6, i8* %94)
%98 = load i8, i8* %90
%99 = and i8 %98, 32
%100 = icmp eq i8 %99, 0
%101 = select i1 %100, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0)
%102 = getelementptr inbounds i8, i8* %0, i64 7
%103 = call i8* @pax25(i8* %10, i8* %102)
%104 = call i32 (i32, i8*, ...) @lprintf(i32 8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* %103)
%105 = call i8* @pax25(i8* %10, i8* %0)
%106 = call i32 (i32, i8*, ...) @lprintf(i32 8, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i8* %105)
%107 = getelementptr inbounds i8, i8* %0, i64 6
%108 = load i8, i8* %107
%109 = icmp sgt i8 %108, -1
%110 = load i8, i8* %90
%111 = xor i8 %110, -1
%112 = lshr i8 %111, 7
%113 = zext i8 %112 to i32
%114 = select i1 %109, i32 2, i32 %113
%115 = select i1 %109, i32 0, i32 %113
%116 = icmp sgt i8 %110, -1
%117 = select i1 %116, i32 %115, i32 %114
%118 = and i8 %110, 1
%119 = getelementptr inbounds i8, i8* %0, i64 14
%120 = add nsw i32 %1, -14
%121 = icmp eq i8 %118, 0
br i1 %121, label %122, label %140
122: ; preds = %89
%123 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
br label %124
124: ; preds = %122, %124
%125 = phi i8* [ %119, %122 ], [ %135, %124 ]
%126 = phi i32 [ %120, %122 ], [ %136, %124 ]
%127 = call i8* @pax25(i8* %10, i8* %125)
%128 = getelementptr inbounds i8, i8* %125, i64 6
%129 = load i8, i8* %128
%130 = icmp sgt i8 %129, -1
%131 = select i1 %130, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0)
%132 = call i32 (i32, i8*, ...) @lprintf(i32 8, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), i8* %127, i8* %131)
%133 = load i8, i8* %128
%134 = and i8 %133, 1
%135 = getelementptr inbounds i8, i8* %125, i64 7
%136 = add nsw i32 %126, -7
%137 = icmp eq i8 %134, 0
br i1 %137, label %124, label %138
138: ; preds = %124
%139 = icmp eq i32 %136, 0
br i1 %139, label %302, label %140
140: ; preds = %69, %89, %138
%141 = phi i8* [ %101, %138 ], [ %101, %89 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), %69 ]
%142 = phi i8* [ %135, %138 ], [ %119, %89 ], [ %82, %69 ]
%143 = phi i8 [ %96, %138 ], [ %96, %89 ], [ 0, %69 ]
%144 = phi i32 [ %117, %138 ], [ %117, %89 ], [ %84, %69 ]
%145 = phi i32 [ %136, %138 ], [ %120, %89 ], [ %83, %69 ]
%146 = zext i8 %143 to i32
%147 = add nsw i32 %145, -2
%148 = call i32 @ftype(i8* %142, i32* %9, i32* %7, i32* %6, i32* %8, i32 %146)
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %142, i64 %149
%151 = sub nsw i32 %145, %148
%152 = load i32, i32* %9
%153 = call i8* @decode_type(i32 %152)
%154 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i8* %153)
switch i32 %144, label %166 [
i32 1, label %155
i32 2, label %159
]
155: ; preds = %140
%156 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0))
%157 = load i32, i32* %8
%158 = icmp eq i32 %157, 0
br i1 %158, label %166, label %163
159: ; preds = %140
%160 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%161 = load i32, i32* %8
%162 = icmp eq i32 %161, 0
br i1 %162, label %166, label %163
163: ; preds = %159, %155
%164 = phi i8* [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0), %155 ], [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0), %159 ]
%165 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* %164)
br label %166
166: ; preds = %163, %140, %159, %155
%167 = load i32, i32* %9
%168 = icmp eq i32 %167, 0
br i1 %168, label %169, label %173
169: ; preds = %166
%170 = load i32, i32* %7
%171 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0), i32 %170)
%172 = load i32, i32* %9
br label %173
173: ; preds = %169, %166
%174 = phi i32 [ %172, %169 ], [ %167, %166 ]
%175 = and i32 %174, 3
%176 = icmp eq i32 %175, 3
br i1 %176, label %180, label %177
177: ; preds = %173
%178 = load i32, i32* %6
%179 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i32 %178)
br label %180
180: ; preds = %177, %173
%181 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
%182 = load i32, i32* %9
switch i32 %182, label %241 [
i32 3, label %183
i32 0, label %183
]
183: ; preds = %180, %180
%184 = icmp sgt i32 %151, 0
br i1 %184, label %185, label %302
185: ; preds = %183
%186 = getelementptr inbounds i8, i8* %150, i64 1
%187 = load i8, i8* %150
%188 = add nsw i32 %151, -1
%189 = icmp eq i8 %187, 8
br i1 %189, label %190, label %206
190: ; preds = %185
%191 = getelementptr inbounds i8, i8* %186, i64 1
%192 = load i8, i8* %186
%193 = zext i8 %192 to i32
%194 = and i32 %193, 128
%195 = icmp eq i32 %194, 0
%196 = select i1 %195, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.22, i64 0, i64 0)
%197 = and i32 %193, 127
%198 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.21, i64 0, i64 0), i8* %196, i32 %197)
br i1 %195, label %199, label %202
199: ; preds = %190
%200 = add nsw i32 %151, -2
%201 = call i32 (i8*, i8*, ...) @sprintf(i8* %11, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.23, i64 0, i64 0), i8* %141, i32 %147)
br label %211
202: ; preds = %190
%203 = getelementptr inbounds i8, i8* %191, i64 1
%204 = load i8, i8* %191
%205 = add nsw i32 %151, -3
br label %206
206: ; preds = %202, %185
%207 = phi i8 [ %204, %202 ], [ %187, %185 ]
%208 = phi i32 [ %205, %202 ], [ %188, %185 ]
%209 = phi i8* [ %203, %202 ], [ %186, %185 ]
%210 = call i32 (i8*, i8*, ...) @sprintf(i8* %11, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.23, i64 0, i64 0), i8* %141, i32 %147)
switch i8 %207, label %237 [
i8 8, label %211
i8 -51, label %216
i8 -49, label %219
i8 -52, label %222
i8 1, label %225
i8 -61, label %228
i8 -50, label %231
i8 -16, label %234
]
211: ; preds = %199, %206
%212 = phi i8* [ %191, %199 ], [ %209, %206 ]
%213 = phi i32 [ %200, %199 ], [ %208, %206 ]
%214 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.24, i64 0, i64 0), i8* %11)
%215 = call i32 @data_dump(i8* %212, i32 %213, i32 %2)
br label %302
216: ; preds = %206
%217 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.25, i64 0, i64 0), i8* %11)
%218 = call i32 @arp_dump(i8* %209, i32 %208)
br label %302
219: ; preds = %206
%220 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.26, i64 0, i64 0), i8* %11)
%221 = call i32 @netrom_dump(i8* %209, i32 %208, i32 %2)
br label %302
222: ; preds = %206
%223 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.27, i64 0, i64 0), i8* %11)
%224 = call i32 @ip_dump(i8* %209, i32 %208, i32 %2)
br label %302
225: ; preds = %206
%226 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.28, i64 0, i64 0), i8* %11)
%227 = call i32 @rose_dump(i8* %209, i32 %208, i32 %2)
br label %302
228: ; preds = %206
%229 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.29, i64 0, i64 0), i8* %11)
%230 = call i32 @data_dump(i8* %209, i32 %208, i32 %2)
br label %302
231: ; preds = %206
%232 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.30, i64 0, i64 0), i8* %11)
%233 = call i32 @flexnet_dump(i8* %209, i32 %208, i32 %2)
br label %302
234: ; preds = %206
%235 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.31, i64 0, i64 0), i8* %11)
%236 = call i32 @data_dump(i8* %209, i32 %208, i32 %2)
br label %302
237: ; preds = %206
%238 = zext i8 %207 to i32
%239 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.32, i64 0, i64 0), i32 %238, i8* %11)
%240 = call i32 @data_dump(i8* %209, i32 %208, i32 %2)
br label %302
241: ; preds = %180
%242 = icmp eq i32 %182, 135
%243 = icmp sgt i32 %151, 2
%244 = select i1 %242, i1 %243, i1 false
br i1 %244, label %245, label %285
245: ; preds = %241
%246 = load i8, i8* %150
%247 = zext i8 %246 to i32
%248 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.33, i64 0, i64 0), i32 %247)
%249 = getelementptr inbounds i8, i8* %150, i64 1
%250 = load i8, i8* %249
%251 = zext i8 %250 to i32
%252 = lshr i32 %251, 5
%253 = lshr i32 %251, 1
%254 = and i32 %253, 7
%255 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.34, i64 0, i64 0), i32 %252, i32 %254)
%256 = getelementptr inbounds i8, i8* %150, i64 2
%257 = load i8, i8* %256
%258 = and i8 %257, 1
%259 = icmp eq i8 %258, 0
br i1 %259, label %263, label %260
260: ; preds = %245
%261 = call i32 (i32, i8*, ...) @lprintf(i32 1, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.35, i64 0, i64 0))
%262 = load i8, i8* %256
br label %263
263: ; preds = %260, %245
%264 = phi i8 [ %262, %260 ], [ %257, %245 ]
%265 = and i8 %264, 2
%266 = icmp eq i8 %265, 0
br i1 %266, label %270, label %267
267: ; preds = %263
%268 = call i32 (i32, i8*, ...) @lprintf(i32 1, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.36, i64 0, i64 0))
%269 = load i8, i8* %256
br label %270
270: ; preds = %267, %263
%271 = phi i8 [ %269, %267 ], [ %264, %263 ]
%272 = and i8 %271, 4
%273 = icmp eq i8 %272, 0
br i1 %273, label %277, label %274
274: ; preds = %270
%275 = call i32 (i32, i8*, ...) @lprintf(i32 1, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.37, i64 0, i64 0))
%276 = load i8, i8* %256
br label %277
277: ; preds = %274, %270
%278 = phi i8 [ %276, %274 ], [ %271, %270 ]
%279 = and i8 %278, 8
%280 = icmp eq i8 %279, 0
br i1 %280, label %283, label %281
281: ; preds = %277
%282 = call i32 (i32, i8*, ...) @lprintf(i32 1, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.38, i64 0, i64 0))
br label %283
283: ; preds = %281, %277
%284 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.24, i64 0, i64 0), i8* %141)
br label %302
285: ; preds = %241
%286 = icmp eq i32 %182, 47
%287 = icmp eq i32 %182, 99
%288 = or i1 %286, %287
%289 = icmp sgt i32 %151, 1
%290 = select i1 %288, i1 %289, i1 false
br i1 %290, label %291, label %300
291: ; preds = %285
%292 = load i8, i8* %150
%293 = zext i8 %292 to i32
%294 = shl nuw nsw i32 %293, 8
%295 = getelementptr inbounds i8, i8* %150, i64 1
%296 = load i8, i8* %295
%297 = zext i8 %296 to i32
%298 = or i32 %294, %297
%299 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.39, i64 0, i64 0), i32 %298, i8* %141)
br label %302
300: ; preds = %285
%301 = call i32 (i32, i8*, ...) @lprintf(i32 7, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.24, i64 0, i64 0), i8* %141)
br label %302
302: ; preds = %211, %216, %219, %222, %225, %228, %231, %234, %237, %183, %291, %300, %283, %138, %87, %17
ret void
}