#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 */
struct rtmsg {
  int rtm_family;
  int rtm_dst_len;
  int rtm_src_len;
  int rtm_tos;
  int rtm_table;
  int rtm_protocol;
  int rtm_scope;
  int rtm_type;
  int rtm_flags;
};
struct nlmsghdr {
  int nlmsg_len;
  int nlmsg_type;
  int nlmsg_flags;
  int nlmsg_seq;
  int nlmsg_pid;
};
struct ifinfomsg {
  int ifi_family;
  int ifi_type;
  int ifi_index;
  int ifi_flags;
  int ifi_change;
};
struct ifaddrmsg {
  int ifa_family;
  int ifa_prefixlen;
  int ifa_flags;
  int ifa_scope;
  int ifa_index;
};

/* Variables and functions */
#define AF_INET 136
#define AF_INET6 135
int IFA_F_DEPRECATED;
int IFA_F_PERMANENT;
int IFA_F_SECONDARY;
int IFA_F_TENTATIVE;
int /*<<< orphan*/ IFA_RTA(struct ifaddrmsg *);
int IFF_ALLMULTI;
int IFF_AUTOMEDIA;
int IFF_BROADCAST;
int IFF_DEBUG;
int IFF_DYNAMIC;
int IFF_LOOPBACK;
int IFF_MASTER;
int IFF_MULTICAST;
int IFF_NOARP;
int IFF_NOTRAILERS;
int IFF_POINTOPOINT;
int IFF_PORTSEL;
int IFF_PROMISC;
int IFF_RUNNING;
int IFF_SLAVE;
int IFF_UP;
int /*<<< orphan*/ IFLA_RTA(struct ifinfomsg *);
void *NLMSG_DATA(struct nlmsghdr *);
#define NLMSG_ERROR 134
int NLMSG_PAYLOAD(struct nlmsghdr *, int);
#define RTM_DELADDR 133
#define RTM_DELLINK 132
#define RTM_DELROUTE 131
int RTM_F_CLONED;
int RTM_F_EQUALIZE;
int RTM_F_NOTIFY;
#define RTM_NEWADDR 130
#define RTM_NEWLINK 129
#define RTM_NEWROUTE 128
int /*<<< orphan*/ RTM_RTA(struct rtmsg *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ netlink_dump_rta(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ stderr;
void netlink_dump(struct nlmsghdr *n) {
  struct ifinfomsg *i;
  struct ifaddrmsg *a;
  struct rtmsg *r;
  int l;
  fprintf(stderr, "%u %u %u %u %u:", n->nlmsg_len, n->nlmsg_type,
          n->nlmsg_flags, n->nlmsg_seq, n->nlmsg_pid);
  switch (n->nlmsg_type) {
  case NLMSG_ERROR:
    fprintf(stderr, "netlink error\n");
    break;
  case RTM_NEWLINK:
    fprintf(stderr, "RTM_NEWLINK\n");
    i = NLMSG_DATA(n);
    l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
    fprintf(stderr, "ifinfomsg: %u %u %d %u %u ", i->ifi_family, i->ifi_type,
            i->ifi_index, i->ifi_flags, i->ifi_change);
    if (i->ifi_flags & IFF_UP)
      fprintf(stderr, "%s ", "IFF_UP");
    ;
    if (i->ifi_flags & IFF_BROADCAST)
      fprintf(stderr, "%s ", "IFF_BROADCAST");
    ;
    if (i->ifi_flags & IFF_DEBUG)
      fprintf(stderr, "%s ", "IFF_DEBUG");
    ;
    if (i->ifi_flags & IFF_LOOPBACK)
      fprintf(stderr, "%s ", "IFF_LOOPBACK");
    ;
    if (i->ifi_flags & IFF_POINTOPOINT)
      fprintf(stderr, "%s ", "IFF_POINTOPOINT");
    ;
    if (i->ifi_flags & IFF_NOTRAILERS)
      fprintf(stderr, "%s ", "IFF_NOTRAILERS");
    ;
    if (i->ifi_flags & IFF_RUNNING)
      fprintf(stderr, "%s ", "IFF_RUNNING");
    ;
    if (i->ifi_flags & IFF_NOARP)
      fprintf(stderr, "%s ", "IFF_NOARP");
    ;
    if (i->ifi_flags & IFF_PROMISC)
      fprintf(stderr, "%s ", "IFF_PROMISC");
    ;
    if (i->ifi_flags & IFF_ALLMULTI)
      fprintf(stderr, "%s ", "IFF_ALLMULTI");
    ;
    if (i->ifi_flags & IFF_MASTER)
      fprintf(stderr, "%s ", "IFF_MASTER");
    ;
    if (i->ifi_flags & IFF_SLAVE)
      fprintf(stderr, "%s ", "IFF_SLAVE");
    ;
    if (i->ifi_flags & IFF_MULTICAST)
      fprintf(stderr, "%s ", "IFF_MULTICAST");
    ;
    if (i->ifi_flags & IFF_PORTSEL)
      fprintf(stderr, "%s ", "IFF_PORTSEL");
    ;
    if (i->ifi_flags & IFF_AUTOMEDIA)
      fprintf(stderr, "%s ", "IFF_AUTOMEDIA");
    ;
    if (i->ifi_flags & IFF_DYNAMIC)
      fprintf(stderr, "%s ", "IFF_DYNAMIC");
    ;
    netlink_dump_rta(IFLA_RTA(i), l, i->ifi_family);
    fprintf(stderr, "\n");
    break;
  case RTM_DELLINK:
    fprintf(stderr, "RTM_DELLINK\n");
    i = NLMSG_DATA(n);
    l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
    fprintf(stderr, "ifinfomsg: %u %u %d %u %u ", i->ifi_family, i->ifi_type,
            i->ifi_index, i->ifi_flags, i->ifi_change);
    if (i->ifi_flags & IFF_UP)
      fprintf(stderr, "%s ", "IFF_UP");
    ;
    if (i->ifi_flags & IFF_BROADCAST)
      fprintf(stderr, "%s ", "IFF_BROADCAST");
    ;
    if (i->ifi_flags & IFF_DEBUG)
      fprintf(stderr, "%s ", "IFF_DEBUG");
    ;
    if (i->ifi_flags & IFF_LOOPBACK)
      fprintf(stderr, "%s ", "IFF_LOOPBACK");
    ;
    if (i->ifi_flags & IFF_POINTOPOINT)
      fprintf(stderr, "%s ", "IFF_POINTOPOINT");
    ;
    if (i->ifi_flags & IFF_NOTRAILERS)
      fprintf(stderr, "%s ", "IFF_NOTRAILERS");
    ;
    if (i->ifi_flags & IFF_RUNNING)
      fprintf(stderr, "%s ", "IFF_RUNNING");
    ;
    if (i->ifi_flags & IFF_NOARP)
      fprintf(stderr, "%s ", "IFF_NOARP");
    ;
    if (i->ifi_flags & IFF_PROMISC)
      fprintf(stderr, "%s ", "IFF_PROMISC");
    ;
    if (i->ifi_flags & IFF_ALLMULTI)
      fprintf(stderr, "%s ", "IFF_ALLMULTI");
    ;
    if (i->ifi_flags & IFF_MASTER)
      fprintf(stderr, "%s ", "IFF_MASTER");
    ;
    if (i->ifi_flags & IFF_SLAVE)
      fprintf(stderr, "%s ", "IFF_SLAVE");
    ;
    if (i->ifi_flags & IFF_MULTICAST)
      fprintf(stderr, "%s ", "IFF_MULTICAST");
    ;
    if (i->ifi_flags & IFF_PORTSEL)
      fprintf(stderr, "%s ", "IFF_PORTSEL");
    ;
    if (i->ifi_flags & IFF_AUTOMEDIA)
      fprintf(stderr, "%s ", "IFF_AUTOMEDIA");
    ;
    if (i->ifi_flags & IFF_DYNAMIC)
      fprintf(stderr, "%s ", "IFF_DYNAMIC");
    ;
    netlink_dump_rta(IFLA_RTA(i), l, i->ifi_family);
    fprintf(stderr, "\n");
    break;
  case RTM_NEWADDR:
    fprintf(stderr, "RTM_NEWADDR\n");
    a = NLMSG_DATA(n);
    l = NLMSG_PAYLOAD(n, sizeof(struct ifaddrmsg));
    fprintf(stderr, "ifaddrmsg: %u %u %u %u %d", a->ifa_family,
            a->ifa_prefixlen, a->ifa_flags, a->ifa_scope, a->ifa_index);
    switch (a->ifa_family) {
    case AF_INET:
      fprintf(stderr, " AF_INET ");
      break;
    case AF_INET6:
      fprintf(stderr, " AF_INET6 ");
      break;
    default:
      fprintf(stderr, " AF unknown ");
      break;
    }
    if (a->ifa_flags & IFA_F_SECONDARY)
      fprintf(stderr, "%s ", "IFA_F_SECONDARY");
    ;
    if (a->ifa_flags & IFA_F_DEPRECATED)
      fprintf(stderr, "%s ", "IFA_F_DEPRECATED");
    ;
    if (a->ifa_flags & IFA_F_TENTATIVE)
      fprintf(stderr, "%s ", "IFA_F_TENTATIVE");
    ;
    if (a->ifa_flags & IFA_F_PERMANENT)
      fprintf(stderr, "%s ", "IFA_F_PERMANENT");
    ;
    netlink_dump_rta(IFA_RTA(a), l, a->ifa_family);
    fprintf(stderr, "\n");
    break;
  case RTM_DELADDR:
    fprintf(stderr, "RTM_DELADDR\n");
    a = NLMSG_DATA(n);
    l = NLMSG_PAYLOAD(n, sizeof(struct ifaddrmsg));
    fprintf(stderr, "ifaddrmsg: %u %u %u %u %d", a->ifa_family,
            a->ifa_prefixlen, a->ifa_flags, a->ifa_scope, a->ifa_index);
    switch (a->ifa_family) {
    case AF_INET:
      fprintf(stderr, " AF_INET ");
      break;
    case AF_INET6:
      fprintf(stderr, " AF_INET6 ");
      break;
    default:
      fprintf(stderr, " AF unknown ");
      break;
    }
    if (a->ifa_flags & IFA_F_SECONDARY)
      fprintf(stderr, "%s ", "IFA_F_SECONDARY");
    ;
    if (a->ifa_flags & IFA_F_DEPRECATED)
      fprintf(stderr, "%s ", "IFA_F_DEPRECATED");
    ;
    if (a->ifa_flags & IFA_F_TENTATIVE)
      fprintf(stderr, "%s ", "IFA_F_TENTATIVE");
    ;
    if (a->ifa_flags & IFA_F_PERMANENT)
      fprintf(stderr, "%s ", "IFA_F_PERMANENT");
    ;
    netlink_dump_rta(IFA_RTA(a), l, a->ifa_family);
    fprintf(stderr, "\n");
    break;
  case RTM_NEWROUTE:
    fprintf(stderr, "RTM_NEWROUTE\n");
    r = NLMSG_DATA(n);
    l = NLMSG_PAYLOAD(n, sizeof(struct rtmsg));
    fprintf(stderr, "rtmsg: %u %u %u %u %u %u %u %u %u", r->rtm_family,
            r->rtm_dst_len, r->rtm_src_len, r->rtm_tos, r->rtm_table,
            r->rtm_protocol, r->rtm_scope, r->rtm_type, r->rtm_flags);
    switch (r->rtm_family) {
    case AF_INET:
      fprintf(stderr, " AF_INET ");
      break;
    case AF_INET6:
      fprintf(stderr, " AF_INET6 ");
      break;
    default:
      fprintf(stderr, " AF unknown ");
      break;
    }
    if (r->rtm_flags & RTM_F_NOTIFY)
      fprintf(stderr, "%s ", "RTM_F_NOTIFY");
    ;
    if (r->rtm_flags & RTM_F_CLONED)
      fprintf(stderr, "%s ", "RTM_F_CLONED");
    ;
    if (r->rtm_flags & RTM_F_EQUALIZE)
      fprintf(stderr, "%s ", "RTM_F_EQUALIZE");
    ;
    netlink_dump_rta(RTM_RTA(r), l, r->rtm_family);
    fprintf(stderr, "\n");
    break;
  case RTM_DELROUTE:
    fprintf(stderr, "RTM_DELROUTE\n");
    r = NLMSG_DATA(n);
    l = NLMSG_PAYLOAD(n, sizeof(struct rtmsg));
    fprintf(stderr, "rtmsg: %u %u %u %u %u %u %u %u %u", r->rtm_family,
            r->rtm_dst_len, r->rtm_src_len, r->rtm_tos, r->rtm_table,
            r->rtm_protocol, r->rtm_scope, r->rtm_type, r->rtm_flags);
    switch (r->rtm_family) {
    case AF_INET:
      fprintf(stderr, " AF_INET ");
      break;
    case AF_INET6:
      fprintf(stderr, " AF_INET6 ");
      break;
    default:
      fprintf(stderr, " AF unknown ");
      break;
    }
    if (r->rtm_flags & RTM_F_NOTIFY)
      fprintf(stderr, "%s ", "RTM_F_NOTIFY");
    ;
    if (r->rtm_flags & RTM_F_CLONED)
      fprintf(stderr, "%s ", "RTM_F_CLONED");
    ;
    if (r->rtm_flags & RTM_F_EQUALIZE)
      fprintf(stderr, "%s ", "RTM_F_EQUALIZE");
    ;
    netlink_dump_rta(RTM_RTA(r), l, r->rtm_family);
    fprintf(stderr, "\n");
    break;
  }
  fprintf(stderr, "\n");
}


x86 assembly (clang, -O0):
<netlink_dump>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0xb8,%rsp
mov    %rdi,-0x20(%rbp)
mov    0x3ddd(%rip),%rax
mov    (%rax),%edi
mov    -0x20(%rbp),%rax
mov    (%rax),%edx
mov    0x4(%rax),%ecx
mov    0x8(%rax),%r8d
mov    0xc(%rax),%r9d
mov    0x10(%rax),%esi
mov    %rsp,%rax
mov    %esi,(%rax)
lea    0x1e6f(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
add    $0xffffff80,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x6,%eax
ja     2201 <netlink_dump+0x1091>
mov    -0x48(%rbp),%rax
lea    0x1e28(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x3d80(%rip),%rax
mov    (%rax),%edi
lea    0x1e3b(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    2201 <netlink_dump+0x1091>
mov    0x3d64(%rip),%rax
mov    (%rax),%edi
lea    0x1e2e(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x14,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    %eax,-0x3c(%rbp)
mov    0x3d2f(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rax
mov    (%rax),%edx
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%r8d
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%r9d
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%eax
lea    0x1de2(%rip),%rsi
mov    %eax,(%rsp)
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3d1a(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     12a7 <netlink_dump+0x137>
mov    0x3cd8(%rip),%rax
mov    (%rax),%edi
lea    0x1dca(%rip),%rsi
lea    0x1dc7(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3c93(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     12de <netlink_dump+0x16e>
mov    0x3ca1(%rip),%rax
mov    (%rax),%edi
lea    0x1d93(%rip),%rsi
lea    0x1d97(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3c94(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1315 <netlink_dump+0x1a5>
mov    0x3c6a(%rip),%rax
mov    (%rax),%edi
lea    0x1d5c(%rip),%rsi
lea    0x1d6e(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3cd5(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     134c <netlink_dump+0x1dc>
mov    0x3c33(%rip),%rax
mov    (%rax),%edi
lea    0x1d25(%rip),%rsi
lea    0x1d41(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3c4e(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1383 <netlink_dump+0x213>
mov    0x3bfc(%rip),%rax
mov    (%rax),%edi
lea    0x1cee(%rip),%rsi
lea    0x1d17(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3b8f(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     13ba <netlink_dump+0x24a>
mov    0x3bc5(%rip),%rax
mov    (%rax),%edi
lea    0x1cb7(%rip),%rsi
lea    0x1cf0(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3bd8(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     13f1 <netlink_dump+0x281>
mov    0x3b8e(%rip),%rax
mov    (%rax),%edi
lea    0x1c80(%rip),%rsi
lea    0x1cc8(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3bc9(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1428 <netlink_dump+0x2b8>
mov    0x3b57(%rip),%rax
mov    (%rax),%edi
lea    0x1c49(%rip),%rsi
lea    0x1c9d(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3b02(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     145f <netlink_dump+0x2ef>
mov    0x3b20(%rip),%rax
mov    (%rax),%edi
lea    0x1c12(%rip),%rsi
lea    0x1c70(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3aeb(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1496 <netlink_dump+0x326>
mov    0x3ae9(%rip),%rax
mov    (%rax),%edi
lea    0x1bdb(%rip),%rsi
lea    0x1c45(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3a9c(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     14cd <netlink_dump+0x35d>
mov    0x3ab2(%rip),%rax
mov    (%rax),%edi
lea    0x1ba4(%rip),%rsi
lea    0x1c1b(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3ab5(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1504 <netlink_dump+0x394>
mov    0x3a7b(%rip),%rax
mov    (%rax),%edi
lea    0x1b6d(%rip),%rsi
lea    0x1bef(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3a9e(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     153b <netlink_dump+0x3cb>
mov    0x3a44(%rip),%rax
mov    (%rax),%edi
lea    0x1b36(%rip),%rsi
lea    0x1bc2(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x39e7(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1572 <netlink_dump+0x402>
mov    0x3a0d(%rip),%rax
mov    (%rax),%edi
lea    0x1aff(%rip),%rsi
lea    0x1b99(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x39f0(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     15a9 <netlink_dump+0x439>
mov    0x39d6(%rip),%rax
mov    (%rax),%edi
lea    0x1ac8(%rip),%rsi
lea    0x1b6e(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x39d1(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     15e0 <netlink_dump+0x470>
mov    0x399f(%rip),%rax
mov    (%rax),%edi
lea    0x1a91(%rip),%rsi
lea    0x1b45(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rdi
call   1060 <IFLA_RTA@plt>
mov    %eax,%edi
mov    -0x3c(%rbp),%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%edx
call   1090 <netlink_dump_rta@plt>
mov    0x3968(%rip),%rax
mov    (%rax),%edi
lea    0x1c2a(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    2201 <netlink_dump+0x1091>
mov    0x394c(%rip),%rax
mov    (%rax),%edi
lea    0x1b05(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x14,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    %eax,-0x3c(%rbp)
mov    0x3917(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rax
mov    (%rax),%edx
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%r8d
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%r9d
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%eax
lea    0x19ca(%rip),%rsi
mov    %eax,(%rsp)
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3902(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     16bf <netlink_dump+0x54f>
mov    0x38c0(%rip),%rax
mov    (%rax),%edi
lea    0x19b2(%rip),%rsi
lea    0x19af(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x387b(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     16f6 <netlink_dump+0x586>
mov    0x3889(%rip),%rax
mov    (%rax),%edi
lea    0x197b(%rip),%rsi
lea    0x197f(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x387c(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     172d <netlink_dump+0x5bd>
mov    0x3852(%rip),%rax
mov    (%rax),%edi
lea    0x1944(%rip),%rsi
lea    0x1956(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x38bd(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1764 <netlink_dump+0x5f4>
mov    0x381b(%rip),%rax
mov    (%rax),%edi
lea    0x190d(%rip),%rsi
lea    0x1929(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3836(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     179b <netlink_dump+0x62b>
mov    0x37e4(%rip),%rax
mov    (%rax),%edi
lea    0x18d6(%rip),%rsi
lea    0x18ff(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3777(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     17d2 <netlink_dump+0x662>
mov    0x37ad(%rip),%rax
mov    (%rax),%edi
lea    0x189f(%rip),%rsi
lea    0x18d8(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x37c0(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1809 <netlink_dump+0x699>
mov    0x3776(%rip),%rax
mov    (%rax),%edi
lea    0x1868(%rip),%rsi
lea    0x18b0(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x37b1(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1840 <netlink_dump+0x6d0>
mov    0x373f(%rip),%rax
mov    (%rax),%edi
lea    0x1831(%rip),%rsi
lea    0x1885(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x36ea(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1877 <netlink_dump+0x707>
mov    0x3708(%rip),%rax
mov    (%rax),%edi
lea    0x17fa(%rip),%rsi
lea    0x1858(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x36d3(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     18ae <netlink_dump+0x73e>
mov    0x36d1(%rip),%rax
mov    (%rax),%edi
lea    0x17c3(%rip),%rsi
lea    0x182d(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3684(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     18e5 <netlink_dump+0x775>
mov    0x369a(%rip),%rax
mov    (%rax),%edi
lea    0x178c(%rip),%rsi
lea    0x1803(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x369d(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     191c <netlink_dump+0x7ac>
mov    0x3663(%rip),%rax
mov    (%rax),%edi
lea    0x1755(%rip),%rsi
lea    0x17d7(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x3686(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1953 <netlink_dump+0x7e3>
mov    0x362c(%rip),%rax
mov    (%rax),%edi
lea    0x171e(%rip),%rsi
lea    0x17aa(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x35cf(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     198a <netlink_dump+0x81a>
mov    0x35f5(%rip),%rax
mov    (%rax),%edi
lea    0x16e7(%rip),%rsi
lea    0x1781(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x35d8(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     19c1 <netlink_dump+0x851>
mov    0x35be(%rip),%rax
mov    (%rax),%edi
lea    0x16b0(%rip),%rsi
lea    0x1756(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    0x35b9(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     19f8 <netlink_dump+0x888>
mov    0x3587(%rip),%rax
mov    (%rax),%edi
lea    0x1679(%rip),%rsi
lea    0x172d(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%rdi
call   1060 <IFLA_RTA@plt>
mov    %eax,%edi
mov    -0x3c(%rbp),%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%edx
call   1090 <netlink_dump_rta@plt>
mov    0x3550(%rip),%rax
mov    (%rax),%edi
lea    0x1812(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    2201 <netlink_dump+0x1091>
mov    0x3534(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    (%rax),%edi
lea    0x16f6(%rip),%rsi
xor    %eax,%eax
mov    %al,-0x4d(%rbp)
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x14,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    -0x58(%rbp),%rcx
mov    %eax,%edx
mov    -0x4d(%rbp),%al
mov    %edx,-0x3c(%rbp)
mov    (%rcx),%edi
mov    -0x30(%rbp),%rsi
mov    (%rsi),%edx
mov    0x4(%rsi),%ecx
mov    0x8(%rsi),%r8d
mov    0xc(%rsi),%r9d
mov    0x10(%rsi),%r10d
mov    %rsp,%rsi
mov    %r10d,(%rsi)
lea    0x16ae(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
sub    $0x87,%eax
je     1ae3 <netlink_dump+0x973>
jmp    1ab4 <netlink_dump+0x944>
mov    -0x4c(%rbp),%eax
sub    $0x88,%eax
jne    1aff <netlink_dump+0x98f>
jmp    1ac7 <netlink_dump+0x957>
mov    0x349a(%rip),%rax
mov    (%rax),%edi
lea    0x1687(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1b16 <netlink_dump+0x9a6>
mov    0x347e(%rip),%rax
mov    (%rax),%edi
lea    0x1675(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1b16 <netlink_dump+0x9a6>
mov    0x3462(%rip),%rax
mov    (%rax),%edi
lea    0x1664(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x34bc(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1b4d <netlink_dump+0x9dd>
mov    0x3432(%rip),%rax
mov    (%rax),%edi
lea    0x1524(%rip),%rsi
lea    0x163a(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x3465(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1b84 <netlink_dump+0xa14>
mov    0x33fb(%rip),%rax
mov    (%rax),%edi
lea    0x14ed(%rip),%rsi
lea    0x1613(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x345e(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1bbb <netlink_dump+0xa4b>
mov    0x33c4(%rip),%rax
mov    (%rax),%edi
lea    0x14b6(%rip),%rsi
lea    0x15ed(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x3387(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1bf2 <netlink_dump+0xa82>
mov    0x338d(%rip),%rax
mov    (%rax),%edi
lea    0x147f(%rip),%rsi
lea    0x15c6(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rdi
call   1080 <IFA_RTA@plt>
mov    %eax,%edi
mov    -0x3c(%rbp),%esi
mov    -0x30(%rbp),%rax
mov    (%rax),%edx
call   1090 <netlink_dump_rta@plt>
mov    0x3356(%rip),%rax
mov    (%rax),%edi
lea    0x1618(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    2201 <netlink_dump+0x1091>
mov    0x333a(%rip),%rax
mov    %rax,-0x68(%rbp)
mov    (%rax),%edi
lea    0x1586(%rip),%rsi
xor    %eax,%eax
mov    %al,-0x5d(%rbp)
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x14,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    -0x68(%rbp),%rcx
mov    %eax,%edx
mov    -0x5d(%rbp),%al
mov    %edx,-0x3c(%rbp)
mov    (%rcx),%edi
mov    -0x30(%rbp),%rsi
mov    (%rsi),%edx
mov    0x4(%rsi),%ecx
mov    0x8(%rsi),%r8d
mov    0xc(%rsi),%r9d
mov    0x10(%rsi),%r10d
mov    %rsp,%rsi
mov    %r10d,(%rsi)
lea    0x14b4(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
sub    $0x87,%eax
je     1cdd <netlink_dump+0xb6d>
jmp    1cae <netlink_dump+0xb3e>
mov    -0x5c(%rbp),%eax
sub    $0x88,%eax
jne    1cf9 <netlink_dump+0xb89>
jmp    1cc1 <netlink_dump+0xb51>
mov    0x32a0(%rip),%rax
mov    (%rax),%edi
lea    0x148d(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1d10 <netlink_dump+0xba0>
mov    0x3284(%rip),%rax
mov    (%rax),%edi
lea    0x147b(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1d10 <netlink_dump+0xba0>
mov    0x3268(%rip),%rax
mov    (%rax),%edi
lea    0x146a(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x32c2(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1d47 <netlink_dump+0xbd7>
mov    0x3238(%rip),%rax
mov    (%rax),%edi
lea    0x132a(%rip),%rsi
lea    0x1440(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x326b(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1d7e <netlink_dump+0xc0e>
mov    0x3201(%rip),%rax
mov    (%rax),%edi
lea    0x12f3(%rip),%rsi
lea    0x1419(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x3264(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1db5 <netlink_dump+0xc45>
mov    0x31ca(%rip),%rax
mov    (%rax),%edi
lea    0x12bc(%rip),%rsi
lea    0x13f3(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x318d(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1dec <netlink_dump+0xc7c>
mov    0x3193(%rip),%rax
mov    (%rax),%edi
lea    0x1285(%rip),%rsi
lea    0x13cc(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x30(%rbp),%rdi
call   1080 <IFA_RTA@plt>
mov    %eax,%edi
mov    -0x3c(%rbp),%esi
mov    -0x30(%rbp),%rax
mov    (%rax),%edx
call   1090 <netlink_dump_rta@plt>
mov    0x315c(%rip),%rax
mov    (%rax),%edi
lea    0x141e(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    2201 <netlink_dump+0x1091>
mov    0x3140(%rip),%rax
mov    %rax,-0x88(%rbp)
mov    (%rax),%edi
lea    0x1396(%rip),%rsi
xor    %eax,%eax
mov    %al,-0x79(%rbp)
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x24,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    -0x88(%rbp),%rcx
mov    %eax,%edx
mov    -0x79(%rbp),%al
mov    %edx,-0x3c(%rbp)
mov    (%rcx),%edi
mov    -0x38(%rbp),%rsi
mov    %rsi,-0x78(%rbp)
mov    (%rsi),%edx
mov    0x4(%rsi),%ecx
mov    0x8(%rsi),%r8d
mov    0xc(%rsi),%r9d
mov    0x10(%rsi),%r10d
mov    0x14(%rsi),%r11d
mov    0x18(%rsi),%ebx
mov    0x1c(%rsi),%r14d
mov    0x20(%rsi),%r15d
mov    %rsp,%rsi
mov    %r15d,0x20(%rsi)
mov    %r14d,0x18(%rsi)
mov    %ebx,0x10(%rsi)
mov    %r11d,0x8(%rsi)
mov    %r10d,(%rsi)
lea    0x132a(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
sub    $0x87,%eax
je     1eff <netlink_dump+0xd8f>
jmp    1ed0 <netlink_dump+0xd60>
mov    -0x6c(%rbp),%eax
sub    $0x88,%eax
jne    1f1b <netlink_dump+0xdab>
jmp    1ee3 <netlink_dump+0xd73>
mov    0x307e(%rip),%rax
mov    (%rax),%edi
lea    0x126b(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1f32 <netlink_dump+0xdc2>
mov    0x3062(%rip),%rax
mov    (%rax),%edi
lea    0x1259(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1f32 <netlink_dump+0xdc2>
mov    0x3046(%rip),%rax
mov    (%rax),%edi
lea    0x1248(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
mov    0x3090(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1f69 <netlink_dump+0xdf9>
mov    0x3016(%rip),%rax
mov    (%rax),%edi
lea    0x1108(%rip),%rsi
lea    0x129c(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
mov    0x3041(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1fa0 <netlink_dump+0xe30>
mov    0x2fdf(%rip),%rax
mov    (%rax),%edi
lea    0x10d1(%rip),%rsi
lea    0x1272(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
mov    0x2fb2(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1fd7 <netlink_dump+0xe67>
mov    0x2fa8(%rip),%rax
mov    (%rax),%edi
lea    0x109a(%rip),%rsi
lea    0x1248(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <RTM_RTA@plt>
mov    %eax,%edi
mov    -0x3c(%rbp),%esi
mov    -0x38(%rbp),%rax
mov    (%rax),%edx
call   1090 <netlink_dump_rta@plt>
mov    0x2f71(%rip),%rax
mov    (%rax),%edi
lea    0x1233(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    2201 <netlink_dump+0x1091>
mov    0x2f55(%rip),%rax
mov    %rax,-0xa8(%rbp)
mov    (%rax),%edi
lea    0x1204(%rip),%rsi
xor    %eax,%eax
mov    %al,-0x99(%rbp)
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x24,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    -0xa8(%rbp),%rcx
mov    %eax,%edx
mov    -0x99(%rbp),%al
mov    %edx,-0x3c(%rbp)
mov    (%rcx),%edi
mov    -0x38(%rbp),%rsi
mov    %rsi,-0x98(%rbp)
mov    (%rsi),%edx
mov    0x4(%rsi),%ecx
mov    0x8(%rsi),%r8d
mov    0xc(%rsi),%r9d
mov    0x10(%rsi),%r10d
mov    0x14(%rsi),%r11d
mov    0x18(%rsi),%ebx
mov    0x1c(%rsi),%r14d
mov    0x20(%rsi),%r15d
mov    %rsp,%rsi
mov    %r15d,0x20(%rsi)
mov    %r14d,0x18(%rsi)
mov    %ebx,0x10(%rsi)
mov    %r11d,0x8(%rsi)
mov    %r10d,(%rsi)
lea    0x1136(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x8c(%rbp)
sub    $0x87,%eax
je     20f9 <netlink_dump+0xf89>
jmp    20c7 <netlink_dump+0xf57>
mov    -0x8c(%rbp),%eax
sub    $0x88,%eax
jne    2115 <netlink_dump+0xfa5>
jmp    20dd <netlink_dump+0xf6d>
mov    0x2e84(%rip),%rax
mov    (%rax),%edi
lea    0x1071(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    212c <netlink_dump+0xfbc>
mov    0x2e68(%rip),%rax
mov    (%rax),%edi
lea    0x105f(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    212c <netlink_dump+0xfbc>
mov    0x2e4c(%rip),%rax
mov    (%rax),%edi
lea    0x104e(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
mov    0x2e96(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     2163 <netlink_dump+0xff3>
mov    0x2e1c(%rip),%rax
mov    (%rax),%edi
lea    0xf0e(%rip),%rsi
lea    0x10a2(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
mov    0x2e47(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     219a <netlink_dump+0x102a>
mov    0x2de5(%rip),%rax
mov    (%rax),%edi
lea    0xed7(%rip),%rsi
lea    0x1078(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
mov    0x2db8(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     21d1 <netlink_dump+0x1061>
mov    0x2dae(%rip),%rax
mov    (%rax),%edi
lea    0xea0(%rip),%rsi
lea    0x104e(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%rdi
call   1030 <RTM_RTA@plt>
mov    %eax,%edi
mov    -0x3c(%rbp),%esi
mov    -0x38(%rbp),%rax
mov    (%rax),%edx
call   1090 <netlink_dump_rta@plt>
mov    0x2d77(%rip),%rax
mov    (%rax),%edi
lea    0x1039(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    0x2d60(%rip),%rax
mov    (%rax),%edi
lea    0x1022(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
add    $0xb8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<netlink_dump>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbp
mov    0x2de3(%rip),%r14
mov    (%r14),%edi
mov    0x0(%rbp),%edx
mov    0x4(%rbp),%ecx
mov    0x8(%rbp),%r8d
mov    0xc(%rbp),%r9d
mov    0x10(%rbp),%ebx
sub    $0x8,%rsp
lea    0xe78(%rip),%rsi
xor    %eax,%eax
push   %rbx
call   1040 <fprintf@plt>
add    $0x10,%rsp
mov    0x4(%rbp),%eax
add    $0xffffff80,%eax
cmp    $0x6,%eax
ja     1729 <netlink_dump+0x5b9>
lea    0xe66(%rip),%rsi
lea    0xe33(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    (%r14),%edi
lea    0xfee(%rip),%rsi
jmp    120a <netlink_dump+0x9a>
mov    (%r14),%edi
lea    0xe4f(%rip),%rsi
jmp    132a <netlink_dump+0x1ba>
mov    (%r14),%edi
lea    0xf3c(%rip),%rsi
jmp    15ed <netlink_dump+0x47d>
mov    (%r14),%edi
lea    0x101d(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbp,%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,%rbx
mov    %rbp,%rdi
mov    $0x24,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    %eax,%r15d
mov    (%r14),%edi
mov    (%rbx),%edx
mov    0x4(%rbx),%ecx
mov    0x8(%rbx),%r8d
mov    0xc(%rbx),%r9d
mov    0x10(%rbx),%r10d
mov    0x14(%rbx),%r11d
mov    0x18(%rbx),%r12d
mov    0x1c(%rbx),%r13d
mov    0x20(%rbx),%ebp
sub    $0x8,%rsp
lea    0xf82(%rip),%rsi
xor    %eax,%eax
push   %rbp
push   %r13
push   %r12
push   %r11
push   %r10
call   1040 <fprintf@plt>
add    $0x30,%rsp
mov    (%rbx),%eax
cmp    $0x87,%eax
lea    0xeec(%rip),%rcx
lea    0xef0(%rip),%rdx
cmove  %rcx,%rdx
cmp    $0x88,%eax
lea    0xecb(%rip),%rsi
cmovne %rdx,%rsi
mov    (%r14),%edi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x20(%rbx),%eax
mov    0x2d25(%rip),%rcx
test   %eax,(%rcx)
je     12ca <netlink_dump+0x15a>
mov    (%r14),%edi
lea    0xdaa(%rip),%rsi
lea    0xf3e(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x20(%rbx),%eax
mov    0x2ce7(%rip),%rcx
test   %eax,(%rcx)
je     12f0 <netlink_dump+0x180>
mov    (%r14),%edi
lea    0xd84(%rip),%rsi
lea    0xf25(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x20(%rbx),%eax
mov    0x2c69(%rip),%rcx
test   %eax,(%rcx)
je     1313 <netlink_dump+0x1a3>
mov    (%r14),%edi
lea    0xd5e(%rip),%rsi
lea    0xf0c(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbx,%rdi
call   1030 <RTM_RTA@plt>
jmp    170c <netlink_dump+0x59c>
mov    (%r14),%edi
lea    0xe00(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbp,%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,%rbx
mov    %rbp,%rdi
mov    $0x14,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    %eax,%r15d
mov    (%r14),%edi
mov    (%rbx),%edx
mov    0x4(%rbx),%ecx
mov    0x8(%rbx),%r8d
mov    0xc(%rbx),%r9d
mov    0x10(%rbx),%ebp
sub    $0x8,%rsp
lea    0xcde(%rip),%rsi
xor    %eax,%eax
push   %rbp
call   1040 <fprintf@plt>
add    $0x10,%rsp
mov    0xc(%rbx),%eax
mov    0x2c18(%rip),%rcx
test   %eax,(%rcx)
je     139f <netlink_dump+0x22f>
mov    (%r14),%edi
lea    0xcd5(%rip),%rsi
lea    0xcd2(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2ba2(%rip),%rcx
test   %eax,(%rcx)
je     13c5 <netlink_dump+0x255>
mov    (%r14),%edi
lea    0xcaf(%rip),%rsi
lea    0xcb3(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2bb4(%rip),%rcx
test   %eax,(%rcx)
je     13eb <netlink_dump+0x27b>
mov    (%r14),%edi
lea    0xc89(%rip),%rsi
lea    0xc9b(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2c06(%rip),%rcx
test   %eax,(%rcx)
je     1411 <netlink_dump+0x2a1>
mov    (%r14),%edi
lea    0xc63(%rip),%rsi
lea    0xc7f(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2b90(%rip),%rcx
test   %eax,(%rcx)
je     1437 <netlink_dump+0x2c7>
mov    (%r14),%edi
lea    0xc3d(%rip),%rsi
lea    0xc66(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2ae2(%rip),%rcx
test   %eax,(%rcx)
je     145d <netlink_dump+0x2ed>
mov    (%r14),%edi
lea    0xc17(%rip),%rsi
lea    0xc50(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2b3c(%rip),%rcx
test   %eax,(%rcx)
je     1483 <netlink_dump+0x313>
mov    (%r14),%edi
lea    0xbf1(%rip),%rsi
lea    0xc39(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2b3e(%rip),%rcx
test   %eax,(%rcx)
je     14a9 <netlink_dump+0x339>
mov    (%r14),%edi
lea    0xbcb(%rip),%rsi
lea    0xc1f(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2a88(%rip),%rcx
test   %eax,(%rcx)
je     14cf <netlink_dump+0x35f>
mov    (%r14),%edi
lea    0xba5(%rip),%rsi
lea    0xc03(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2a82(%rip),%rcx
test   %eax,(%rcx)
je     14f5 <netlink_dump+0x385>
mov    (%r14),%edi
lea    0xb7f(%rip),%rsi
lea    0xbe9(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2a44(%rip),%rcx
test   %eax,(%rcx)
je     151b <netlink_dump+0x3ab>
mov    (%r14),%edi
lea    0xb59(%rip),%rsi
lea    0xbd0(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2a6e(%rip),%rcx
test   %eax,(%rcx)
je     1541 <netlink_dump+0x3d1>
mov    (%r14),%edi
lea    0xb33(%rip),%rsi
lea    0xbb5(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x2a68(%rip),%rcx
test   %eax,(%rcx)
je     1567 <netlink_dump+0x3f7>
mov    (%r14),%edi
lea    0xb0d(%rip),%rsi
lea    0xb99(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x29c2(%rip),%rcx
test   %eax,(%rcx)
je     158d <netlink_dump+0x41d>
mov    (%r14),%edi
lea    0xae7(%rip),%rsi
lea    0xb81(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x29dc(%rip),%rcx
test   %eax,(%rcx)
je     15b3 <netlink_dump+0x443>
mov    (%r14),%edi
lea    0xac1(%rip),%rsi
lea    0xb67(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0xc(%rbx),%eax
mov    0x29ce(%rip),%rcx
test   %eax,(%rcx)
je     15d6 <netlink_dump+0x466>
mov    (%r14),%edi
lea    0xa9b(%rip),%rsi
lea    0xb4f(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbx,%rdi
call   1060 <IFLA_RTA@plt>
jmp    170c <netlink_dump+0x59c>
mov    (%r14),%edi
lea    0xbd4(%rip),%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbp,%rdi
call   1070 <NLMSG_DATA@plt>
mov    %rax,%rbx
mov    %rbp,%rdi
mov    $0x14,%esi
call   1050 <NLMSG_PAYLOAD@plt>
mov    %eax,%r15d
mov    (%r14),%edi
mov    (%rbx),%edx
mov    0x4(%rbx),%ecx
mov    0x8(%rbx),%r8d
mov    0xc(%rbx),%r9d
mov    0x10(%rbx),%ebp
sub    $0x8,%rsp
lea    0xb17(%rip),%rsi
xor    %eax,%eax
push   %rbp
call   1040 <fprintf@plt>
add    $0x10,%rsp
mov    (%rbx),%eax
cmp    $0x87,%eax
lea    0xb21(%rip),%rcx
lea    0xb25(%rip),%rdx
cmove  %rcx,%rdx
cmp    $0x88,%eax
lea    0xb00(%rip),%rsi
cmovne %rdx,%rsi
mov    (%r14),%edi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8(%rbx),%eax
mov    0x296a(%rip),%rcx
test   %eax,(%rcx)
je     1695 <netlink_dump+0x525>
mov    (%r14),%edi
lea    0x9df(%rip),%rsi
lea    0xaf5(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8(%rbx),%eax
mov    0x2924(%rip),%rcx
test   %eax,(%rcx)
je     16bb <netlink_dump+0x54b>
mov    (%r14),%edi
lea    0x9b9(%rip),%rsi
lea    0xadf(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8(%rbx),%eax
mov    0x292e(%rip),%rcx
test   %eax,(%rcx)
je     16e1 <netlink_dump+0x571>
mov    (%r14),%edi
lea    0x993(%rip),%rsi
lea    0xaca(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    0x8(%rbx),%eax
mov    0x2868(%rip),%rcx
test   %eax,(%rcx)
je     1704 <netlink_dump+0x594>
mov    (%r14),%edi
lea    0x96d(%rip),%rsi
lea    0xab4(%rip),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %rbx,%rdi
call   1080 <IFA_RTA@plt>
mov    (%rbx),%edx
mov    %eax,%edi
mov    %r15d,%esi
call   1090 <netlink_dump_rta@plt>
lea    0xb14(%rip),%rsi
mov    (%r14),%edi
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    (%r14),%edi
lea    0xb00(%rip),%rsi
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <fprintf@plt>

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

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