LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/msleep/main.c
// Function: main
int
main(int argc, char * argv[])
{
	int msec;
	struct timespec ts;

	WARNP_INIT;

	/* Parse command line. */
	if (argc != 2) {
		fprintf(stderr, "usage: %s milliseconds\n", argv[0]);
		goto err0;
	}
	if (PARSENUM(&msec, argv[1], 0, INT_MAX)) {
		warnp("PARSNEUM");
		goto err0;
	}

	/* Sleep for the desired time. */
	ts.tv_sec = msec / 1000;
	ts.tv_nsec = (msec % 1000) * 1000000;
	if (nanosleep(&ts, NULL)) {
		warnp("nanosleep");
		goto err0;
	}

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x127c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1660
jmp 0x127e
cmpl $0x2, -0x8(%rbp)
je 0x12a8
movq 0x2d6d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xd74(%rip), %rsi       # 0x2010
movb $0x0, %al
callq 0x10d0
jmp 0x1423
callq 0x1070
movl $0x0, (%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x12f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorps %xmm0, %xmm0
movsd 0xd28(%rip), %xmm1      # 0x2008
xorl %esi, %esi
callq 0x1430
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
jmp 0x1366
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movb $0x1, %al
testb $0x1, %al
jne 0x12ff
jmp 0x133b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovlel %eax, %eax
movslq %eax, %rsi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl $0x0, %edx
cmovlel %ecx, %eax
movslq %eax, %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x14e0
movl %eax, -0x14(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1363
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x15a0
movl %eax, -0x14(%rbp)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
callq 0x1070
cmpl $0x0, (%rax)
je 0x13a9
jmp 0x1372
callq 0x1070
cmpl $0x0, (%rax)
je 0x1397
leaq 0xca5(%rip), %rdi       # 0x2028
movb $0x0, %al
callq 0x1720
callq 0x1070
movl $0x0, (%rax)
jmp 0x13a5
leaq 0xc8a(%rip), %rdi       # 0x2028
movb $0x0, %al
callq 0x1970
jmp 0x13a7
jmp 0x1423
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
cmpl $0x0, %eax
je 0x141c
jmp 0x13e5
callq 0x1070
cmpl $0x0, (%rax)
je 0x140a
leaq 0xc3b(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1720
callq 0x1070
movl $0x0, (%rax)
jmp 0x1418
leaq 0xc20(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1970
jmp 0x141a
jmp 0x1423
xorl %edi, %edi
callq 0x1120
movl $0x1, %edi
callq 0x1120
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/main.c
// Function: epoll_ET_add
void epoll_ET_add(tun_data_t *data, int epollfd, u32_t events) {
  struct epoll_event event;

  if (setnonblocking(data->fd) == -1) {
    ELOG("setnonblocking()");
    return;
  }
  event.data.ptr = data;
  event.events = events | EPOLLET;
  if (epoll_ctl(epollfd, EPOLL_CTL_ADD, data->fd, &event) == -1) {
    ELOG("epoll_ctl()");
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x3090
cmpl $-0x1, %eax
jne 0x2f62
jmp 0x2f35
movq 0x2c0bc(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x24124(%rip), %rsi     # 0x2706a
leaq 0x240e5(%rip), %rdx     # 0x27032
movl $0x8b, %ecx
leaq 0x24156(%rip), %r8      # 0x270af
movb $0x0, %al
callq 0x2170
jmp 0x2fc1
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
movl $0x1, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2130
cmpl $-0x1, %eax
jne 0x2fc1
jmp 0x2f94
movq 0x2c05d(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x240c5(%rip), %rsi     # 0x2706a
leaq 0x24086(%rip), %rdx     # 0x27032
movl $0x91, %ecx
leaq 0x24108(%rip), %r8      # 0x270c0
movb $0x0, %al
callq 0x2170
jmp 0x2fc1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/main.c
// Function: hex_dump
static void hex_dump(char *buf, int len) {
  int i;

  for (i = 0; i < len; i++) {
    printf("%02X ", (uint8_t)buf[i]);

    if (((i + 1) % 16) == 0) {
      printf("\n");
    } else if (((i + 1) % 8) == 0) {
      printf(" ");
    }
  }

  if ((len % 16) != 0) {
    printf("\n");
  }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x305b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x240d4(%rip), %rdi     # 0x270d5
movb $0x0, %al
callq 0x20d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x302b
leaq 0x24f89(%rip), %rdi     # 0x27fab
movb $0x0, %al
callq 0x20d0
jmp 0x304e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x304c
leaq 0x24094(%rip), %rdi     # 0x270d9
movb $0x0, %al
callq 0x20d0
jmp 0x304e
jmp 0x3050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2fe6
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x3079
leaq 0x24f39(%rip), %rdi     # 0x27fab
movb $0x0, %al
callq 0x20d0
leaq 0x24f2b(%rip), %rdi     # 0x27fab
movb $0x0, %al
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/main.c
// Function: epoll_ET_mod
void epoll_ET_mod(tun_data_t *data, int epollfd, u32_t events) {
  struct epoll_event event;

  event.data.ptr = data;
  event.events = events | EPOLLET;
  if (epoll_ctl(epollfd, EPOLL_CTL_MOD, data->fd, &event) == -1) {
    ELOG("epoll_ctl()");
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
movl $0x3, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2130
cmpl $-0x1, %eax
jne 0x3141
jmp 0x3114
movq 0x2bedd(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x23f45(%rip), %rsi     # 0x2706a
leaq 0x23f06(%rip), %rdx     # 0x27032
movl $0x9d, %ecx
leaq 0x23f88(%rip), %r8      # 0x270c0
movb $0x0, %al
callq 0x2170
jmp 0x3141
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/main.c
// Function: output
static err_t output(struct pbuf *p) {
  static char buf[MTU];
  int nwrite, bufLen;

  bufLen = pbuf_copy_partial(p, buf, p->tot_len, 0);
  nwrite = write(tunfd, buf, bufLen);
  if (nwrite == -1) {
    ELOG("output()");
  }
  return ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
leaq 0x2c015(%rip), %rsi     # 0x2f180
xorl %ecx, %ecx
movzwl 0x10(%rax), %edx
callq 0x8250
movzwl %ax, %eax
movl %eax, -0x10(%rbp)
movl 0x2bff2(%rip), %edi     # 0x2f174
movslq -0x10(%rbp), %rdx
leaq 0x2bff3(%rip), %rsi     # 0x2f180
callq 0x2090
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x31ca
jmp 0x319d
movq 0x2be54(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x23ebc(%rip), %rsi     # 0x2706a
leaq 0x23e7d(%rip), %rdx     # 0x27032
movl $0x7c, %ecx
leaq 0x23f0b(%rip), %r8      # 0x270cc
movb $0x0, %al
callq 0x2170
jmp 0x31ca
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/redefine.c
// Function: MALLOC
void *MALLOC(size_t n) {
  void *p = malloc(n);
  if (!p) {
    fprintf(stderr, "\033[31mMALLOC\033[0m %s:%d\n", __FILE__, __LINE__);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x322e
movq 0x2bdf1(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x23eca(%rip), %rsi     # 0x270db
leaq 0x23eda(%rip), %rdx     # 0x270f2
movl $0x6, %ecx
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2200
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/tcp.c
// Function: tun_tcp_close
static void tun_tcp_close(tun_data_t *data) {
  ELOG(__FUNCTION__);

  tcp_arg(data->tpcb, NULL);
  tcp_err(data->tpcb, NULL);
  tcp_recv(data->tpcb, NULL);
  tcp_sent(data->tpcb, NULL);

  tcp_close(data->tpcb);
  close(data->fd);
  tun_tcp_free(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2b9d5(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x23a3d(%rip), %rsi     # 0x2706a
leaq 0x2474b(%rip), %rdx     # 0x27d7f
movl $0xac, %ecx
leaq 0x23b8c(%rip), %r8      # 0x271cc
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xddc0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xded0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xddf0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xde60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb2a0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x3db0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/tcp.c
// Function: tun_tcp_error
static void tun_tcp_error(void *arg, err_t err) {
  ELOG(__FUNCTION__);
  printf("err %d\n", err);

  close(((tun_data_t *)arg)->fd);
  tun_tcp_free((tun_data_t *)arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq 0x2b91f(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x23987(%rip), %rsi     # 0x2706a
leaq 0x24695(%rip), %rdx     # 0x27d7f
movl $0x86, %ecx
leaq 0x23aa6(%rip), %r8      # 0x2719c
movb $0x0, %al
callq 0x2170
movsbl -0x9(%rbp), %esi
leaq 0x23aa2(%rip), %rdi     # 0x271aa
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x3db0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/tcp.c
// Function: handle_epoll_tcp
void handle_epoll_tcp(uint32_t events, tun_data_t *data) {
  ELOG(__FUNCTION__);

  if (data->server_status == TUN_CONNECTING) {
    data->server_status = TUN_CONNECTED;
  }
  if (events & EPOLLIN) {
    epoll_to_lwip(data);
  } else {
    lwip_to_epoll(data);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x2b642(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x236aa(%rip), %rsi     # 0x2706a
leaq 0x243b8(%rip), %rdx     # 0x27d7f
movl $0x97, %ecx
leaq 0x23775(%rip), %r8      # 0x27148
movb $0x0, %al
callq 0x2170
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x39ef
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3a05
movq -0x10(%rbp), %rdi
callq 0x3a20
jmp 0x3a0e
movq -0x10(%rbp), %rdi
callq 0x3c50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/tcp.c
// Function: lwip_to_epoll
static void lwip_to_epoll(tun_data_t *data) {
  ELOG(__FUNCTION__);

  int nwrite;
  extern int errno;

  /* exit if sending is completed or unable to send */
  nwrite = write(data->fd, data->client_buf, data->client_buf_len);
  if (nwrite == -1 && errno != EAGAIN) {
    ELOG("write()");
    tun_tcp_close(data);
    return;
  } else if (nwrite > 0) {
    tcp_recved(data->tpcb, nwrite);
    data->client_buf_len -= nwrite;
    memmove(data->client_buf + nwrite, data->client_buf, data->client_buf_len);
  }

  /* TUN_CLOSE and no buf left, should shutdown write */
  if (data->client_buf_len == 0 && data->client_status == TUN_CLOSE) {
    ELOG("shutdown clientserver write");

    epoll_ET_mod(data, epollfd,
                 EPOLLIN); /* without this step epoll will loop indefinitely */
    shutdown(data->fd, SHUT_WR);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2b395(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x233fd(%rip), %rsi     # 0x2706a
leaq 0x2410b(%rip), %rdx     # 0x27d7f
movl $0xba, %ecx
leaq 0x2355a(%rip), %r8      # 0x271da
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rdx
callq 0x2090
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x3cf1
callq 0x2050
cmpl $0xb, (%rax)
je 0x3cf1
jmp 0x3cb8
movq 0x2b339(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x233a1(%rip), %rsi     # 0x2706a
leaq 0x240af(%rip), %rdx     # 0x27d7f
movl $0xc2, %ecx
leaq 0x23541(%rip), %r8      # 0x2721d
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rdi
callq 0x3610
jmp 0x3da8
cmpl $0x0, -0xc(%rbp)
jle 0x3d3d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %eax
movzwl %ax, %esi
callq 0xc8c0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rdx
callq 0x21d0
jmp 0x3d3f
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x3da8
movq -0x8(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x3da8
jmp 0x3d55
movq 0x2b29c(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x23304(%rip), %rsi     # 0x2706a
leaq 0x24012(%rip), %rdx     # 0x27d7f
movl $0xcd, %ecx
leaq 0x2346f(%rip), %r8      # 0x271e8
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rdi
leaq 0x2b3e5(%rip), %rax     # 0x2f170
movl (%rax), %esi
movl $0x1, %edx
callq 0x30d0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movl $0x1, %esi
callq 0x20a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/tcp.c
// Function: tun_tcp_free
static void tun_tcp_free(tun_data_t *data) {
  ELOG(__FUNCTION__);

  FREE(data->client_buf);
  FREE(data->server_buf);
  FREE(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2b235(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x2329d(%rip), %rsi     # 0x2706a
leaq 0x23fab(%rip), %rdx     # 0x27d7f
movl $0xa4, %ecx
leaq 0x233d2(%rip), %r8      # 0x271b2
movb $0x0, %al
callq 0x2170
jmp 0x3de9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x3e04
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x3e1f
movq -0x8(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/ip.c
// Function: ipaddr_ntoa
char *ipaddr_ntoa(const ip_addr_t *addr)
{
  if (addr == NULL) {
    return NULL;
  }
  if (IP_IS_V6(addr)) {
    return ip6addr_ntoa(ip_2_ip6(addr));
  } else {
    return ip4addr_ntoa(ip_2_ip4(addr));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x444d
movq $0x0, -0x8(%rbp)
jmp 0x447d
cmpq $0x0, -0x10(%rbp)
je 0x4470
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x6, %eax
jne 0x4470
movq -0x10(%rbp), %rdi
callq 0x1e080
movq %rax, -0x8(%rbp)
jmp 0x447d
movq -0x10(%rbp), %rdi
callq 0x1a640
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/ip.c
// Function: ipaddr_ntoa_r
char *ipaddr_ntoa_r(const ip_addr_t *addr, char *buf, int buflen)
{
  if (addr == NULL) {
    return NULL;
  }
  if (IP_IS_V6(addr)) {
    return ip6addr_ntoa_r(ip_2_ip6(addr), buf, buflen);
  } else {
    return ip4addr_ntoa_r(ip_2_ip4(addr), buf, buflen);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x44b4
movq $0x0, -0x8(%rbp)
jmp 0x44f2
cmpq $0x0, -0x10(%rbp)
je 0x44de
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x6, %eax
jne 0x44de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1e0b0
movq %rax, -0x8(%rbp)
jmp 0x44f2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1a670
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/ip.c
// Function: ipaddr_aton
int
ipaddr_aton(const char *cp, ip_addr_t *addr)
{
  if (cp != NULL) {
    const char *c;
    for (c = cp; *c != 0; c++) {
      if (*c == ':') {
        /* contains a colon: IPv6 address */
        if (addr) {
          IP_SET_TYPE_VAL(*addr, IPADDR_TYPE_V6);
        }
        return ip6addr_aton(cp, ip_2_ip6(addr));
      } else if (*c == '.') {
        /* contains a dot: IPv4 address */
        break;
      }
    }
    /* call ip4addr_aton as fallback or if IPv4 was found */
    if (addr) {
      IP_SET_TYPE_VAL(*addr, IPADDR_TYPE_V4);
    }
    return ip4addr_aton(cp, ip_2_ip4(addr));
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45a5
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4580
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x4560
cmpq $0x0, -0x18(%rbp)
je 0x454e
jmp 0x4544
movq -0x18(%rbp), %rax
movb $0x6, 0x14(%rax)
jmp 0x454e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dcd0
movl %eax, -0x4(%rbp)
jmp 0x45ac
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x456e
jmp 0x4580
jmp 0x4570
jmp 0x4572
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4523
cmpq $0x0, -0x18(%rbp)
je 0x4593
jmp 0x4589
movq -0x18(%rbp), %rax
movb $0x0, 0x14(%rax)
jmp 0x4593
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a2a0
movl %eax, -0x4(%rbp)
jmp 0x45ac
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/ip.c
// Function: ip_input
err_t
ip_input(struct pbuf *p, struct netif *inp)
{
  if (p != NULL) {
    if (IP_HDR_GET_VERSION(p->payload) == 6) {
      return ip6_input(p, inp);
    }
    return ip4_input(p, inp);
  }
  return ERR_VAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x460e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
cmpl $0x6, %eax
jne 0x45fc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c590
movb %al, -0x1(%rbp)
jmp 0x4612
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x196e0
movb %al, -0x1(%rbp)
jmp 0x4612
movb $-0x6, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/mem.c
// Function: mem_malloc
void *
mem_malloc(mem_size_t size)
{
  void *ret = mem_clib_malloc(size + MEM_LIBC_STATSHELPER_SIZE);
  if (ret == NULL) {
    MEM_STATS_INC_LOCKED(err);
  } else {
    LWIP_ASSERT("malloc() must return aligned memory", LWIP_MEM_ALIGN(ret) == ret);
#if LWIP_STATS && MEM_STATS
    *(mem_size_t *)ret = size;
    ret = (u8_t *)ret + MEM_LIBC_STATSHELPER_SIZE;
    MEM_STATS_INC_USED_LOCKED(used, size);
#endif
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x0, %rdi
callq 0x21a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x467a
jmp 0x4676
jmp 0x4678
jmp 0x46c7
jmp 0x467c
movq -0x10(%rbp), %rax
addq $0x1, %rax
subq $0x1, %rax
andq $-0x1, %rax
cmpq -0x10(%rbp), %rax
je 0x46c3
jmp 0x4694
leaq 0x22c31(%rip), %rdi     # 0x272cc
leaq 0x22c52(%rip), %rsi     # 0x272f4
movl $0xd5, %edx
leaq 0x22c6a(%rip), %rcx     # 0x27318
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x46c5
jmp 0x46c7
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/memp.c
// Function: memp_malloc_pool
memp_malloc_pool(const struct memp_desc *desc)
#else
memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line)
#endif
{
  LWIP_ASSERT("invalid pool desc", desc != NULL);
  if (desc == NULL) {
    return NULL;
  }

#if !MEMP_OVERFLOW_CHECK
  return do_memp_malloc_pool(desc);
#else
  return do_memp_malloc_pool_fn(desc, file, line);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4864
jmp 0x4835
leaq 0x22a90(%rip), %rdi     # 0x272cc
leaq 0x22b88(%rip), %rsi     # 0x273cb
movl $0x13c, %edx            # imm = 0x13C
leaq 0x22b8e(%rip), %rcx     # 0x273dd
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x4866
cmpq $0x0, -0x10(%rbp)
jne 0x4877
movq $0x0, -0x8(%rbp)
jmp 0x4884
movq -0x10(%rbp), %rdi
callq 0x4890
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/memp.c
// Function: memp_free_pool
void
memp_free_pool(const struct memp_desc *desc, void *mem)
{
  LWIP_ASSERT("invalid pool desc", desc != NULL);
  if ((desc == NULL) || (mem == NULL)) {
    return;
  }

  do_memp_free_pool(desc, mem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x49e8
jmp 0x49b9
leaq 0x2290c(%rip), %rdi     # 0x272cc
leaq 0x22a04(%rip), %rsi     # 0x273cb
movl $0x195, %edx            # imm = 0x195
leaq 0x22a0a(%rip), %rcx     # 0x273dd
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x49ea
cmpq $0x0, -0x8(%rbp)
je 0x49f8
cmpq $0x0, -0x10(%rbp)
jne 0x49fa
jmp 0x4a07
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4a10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/memp.c
// Function: memp_free
void
memp_free(memp_t type, void *mem)
{
#ifdef LWIP_HOOK_MEMP_AVAILABLE
  struct memp *old_first;
#endif

  LWIP_ERROR("memp_free: type < MEMP_MAX", (type < MEMP_MAX), return;);

  if (mem == NULL) {
    return;
  }

#if MEMP_OVERFLOW_CHECK >= 2
  memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK >= 2 */

#ifdef LWIP_HOOK_MEMP_AVAILABLE
  old_first = *memp_pools[type]->tab;
#endif

  do_memp_free_pool(memp_pools[type], mem);

#ifdef LWIP_HOOK_MEMP_AVAILABLE
  if (old_first == NULL) {
    LWIP_HOOK_MEMP_AVAILABLE(type);
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xc, -0x4(%rbp)
jb 0x4ac6
jmp 0x4a97
leaq 0x2282e(%rip), %rdi     # 0x272cc
leaq 0x22970(%rip), %rsi     # 0x27415
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x2292c(%rip), %rcx     # 0x273dd
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x4ac8
cmpq $0x0, -0x10(%rbp)
jne 0x4ad1
jmp 0x4aea
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x2a1d3(%rip), %rax     # 0x2ecb0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x4a10
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_init
void
netif_init(void)
{
#if LWIP_HAVE_LOOPIF
#if LWIP_IPV4
#define LOOPIF_ADDRINIT &loop_ipaddr, &loop_netmask, &loop_gw,
  ip4_addr_t loop_ipaddr, loop_netmask, loop_gw;
  IP4_ADDR(&loop_gw, 127, 0, 0, 1);
  IP4_ADDR(&loop_ipaddr, 127, 0, 0, 1);
  IP4_ADDR(&loop_netmask, 255, 0, 0, 0);
#else /* LWIP_IPV4 */
#define LOOPIF_ADDRINIT
#endif /* LWIP_IPV4 */

#if NO_SYS
  netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, ip_input);
#else  /* NO_SYS */
  netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, tcpip_input);
#endif /* NO_SYS */

#if LWIP_IPV6
  IP_ADDR6_HOST(loop_netif.ip6_addr, 0, 0, 0, 0x00000001UL);
  loop_netif.ip6_addr_state[0] = IP6_ADDR_VALID;
#endif /* LWIP_IPV6 */

  netif_set_link_up(&loop_netif);
  netif_set_up(&loop_netif);

#endif /* LWIP_HAVE_LOOPIF */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x100007f, -0xc(%rbp)  # imm = 0x100007F
movl $0x100007f, -0x4(%rbp)  # imm = 0x100007F
movl $0xff, -0x8(%rbp)
leaq 0x2acb4(%rip), %rdi     # 0x2f7c8
leaq -0x4(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0xc(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq 0x5d4(%rip), %r9        # 0x5100
leaq -0x573(%rip), %rax      # 0x45c0
movq %rax, (%rsp)
callq 0x4ba0
jmp 0x4b3e
movl $0x0, 0x2acd0(%rip)     # 0x2f818
movl $0x0, 0x2acca(%rip)     # 0x2f81c
movl $0x0, 0x2acc4(%rip)     # 0x2f820
movl $0x1000000, 0x2acbe(%rip) # imm = 0x1000000
movb $0x0, 0x2acbb(%rip)     # 0x2f828
jmp 0x4b6f
movb $0x6, 0x2acb6(%rip)     # 0x2f82c
jmp 0x4b78
movb $0x10, 0x2ace1(%rip)    # 0x2f860
leaq 0x2ac42(%rip), %rdi     # 0x2f7c8
callq 0x5190
leaq 0x2ac36(%rip), %rdi     # 0x2f7c8
callq 0x5230
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_loopif_init
static err_t
netif_loopif_init(struct netif *netif)
{
  LWIP_ASSERT("netif_loopif_init: invalid netif", netif != NULL);

  /* initialize the snmp variables and counters inside the struct netif
   * ifSpeed: no assumption can be made!
   */
  MIB2_INIT_NETIF(netif, snmp_ifType_softwareLoopback, 0);

  netif->name[0] = 'l';
  netif->name[1] = 'o';
#if LWIP_IPV4
  netif->output = netif_loop_output_ipv4;
#endif
#if LWIP_IPV6
  netif->output_ip6 = netif_loop_output_ipv6;
#endif
#if LWIP_LOOPIF_MULTICAST
  netif_set_flags(netif, NETIF_FLAG_IGMP);
#endif
  NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_DISABLE_ALL);
  return ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5144
jmp 0x5115
leaq 0x221b0(%rip), %rdi     # 0x272cc
leaq 0x22705(%rip), %rsi     # 0x27828
movl $0x99, %edx
leaq 0x2235e(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x5146
movq -0x8(%rbp), %rax
movb $0x6c, 0xec(%rax)
movq -0x8(%rbp), %rax
movb $0x6f, 0xed(%rax)
movq -0x8(%rbp), %rax
leaq 0x1bf9(%rip), %rcx      # 0x6d60
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rax
leaq 0x1c17(%rip), %rcx      # 0x6d90
movq %rcx, 0xd0(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_set_link_up
void
netif_set_link_up(struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_link_up: invalid netif", netif != NULL, return);

  if (!(netif->flags & NETIF_FLAG_LINK_UP)) {
    netif_set_flags(netif, NETIF_FLAG_LINK_UP);

#if LWIP_DHCP
    dhcp_network_changed(netif);
#endif /* LWIP_DHCP */

#if LWIP_AUTOIP
    autoip_network_changed(netif);
#endif /* LWIP_AUTOIP */

    netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6);
#if LWIP_IPV6
    nd6_restart_netif(netif);
#endif /* LWIP_IPV6 */

    NETIF_LINK_CALLBACK(netif);
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    {
      netif_ext_callback_args_t args;
      args.link_changed.state = 1;
      netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args);
    }
#endif
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x51d4
jmp 0x51a5
leaq 0x22120(%rip), %rdi     # 0x272cc
leaq 0x22425(%rip), %rsi     # 0x275d8
movl $0x3e0, %edx            # imm = 0x3E0
leaq 0x222ce(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x51d6
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x521c
jmp 0x51eb
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
orl $0x4, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xeb(%rax)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x5b70
movq -0x8(%rbp), %rdi
callq 0x24d90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_set_up
void
netif_set_up(struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_up: invalid netif", netif != NULL, return);

  if (!(netif->flags & NETIF_FLAG_UP)) {
    netif_set_flags(netif, NETIF_FLAG_UP);

    MIB2_COPY_SYSUPTIME_TO(&netif->ts);

    NETIF_STATUS_CALLBACK(netif);

#if LWIP_NETIF_EXT_STATUS_CALLBACK
    {
      netif_ext_callback_args_t args;
      args.status_changed.state = 1;
      netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args);
    }
#endif

    netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6);
#if LWIP_IPV6
    nd6_restart_netif(netif);
#endif /* LWIP_IPV6 */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5274
jmp 0x5245
leaq 0x22080(%rip), %rdi     # 0x272cc
leaq 0x2234b(%rip), %rsi     # 0x2759e
movl $0x350, %edx            # imm = 0x350
leaq 0x2222e(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x5276
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x52bc
jmp 0x528b
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
orl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xeb(%rax)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x5b70
movq -0x8(%rbp), %rdi
callq 0x24d90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_set_ipaddr
void
netif_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr)
{
  ip_addr_t old_addr;

  LWIP_ERROR("netif_set_ipaddr: invalid netif", netif != NULL, return);

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */
  if (ipaddr == NULL) {
    ipaddr = IP4_ADDR_ANY4;
  }

  LWIP_ASSERT_CORE_LOCKED();

  if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) {
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    netif_ext_callback_args_t args;
    args.ipv4_changed.old_address = &old_addr;
    netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_ADDRESS_CHANGED, &args);
#endif
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5538
jmp 0x5509
leaq 0x21dbc(%rip), %rdi     # 0x272cc
leaq 0x2202a(%rip), %rsi     # 0x27541
movl $0x1f8, %edx            # imm = 0x1F8
leaq 0x21f6a(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x553a
cmpq $0x0, -0x10(%rbp)
jne 0x554c
leaq 0x24204(%rip), %rax     # 0x2974c
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5570
cmpl $0x0, %eax
je 0x5564
jmp 0x5564
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_set_netmask
void
netif_set_netmask(struct netif *netif, const ip4_addr_t *netmask)
{
#if LWIP_NETIF_EXT_STATUS_CALLBACK
  ip_addr_t old_nm_val;
  ip_addr_t *old_nm = &old_nm_val;
#else
  ip_addr_t *old_nm = NULL;
#endif
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_netmask: invalid netif", netif != NULL, return);

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */
  if (netmask == NULL) {
    netmask = IP4_ADDR_ANY4;
  }

  if (netif_do_set_netmask(netif, netmask, old_nm)) {
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    netif_ext_callback_args_t args;
    args.ipv4_changed.old_netmask = old_nm;
    netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_NETMASK_CHANGED, &args);
#endif
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5780
jmp 0x5751
leaq 0x21b74(%rip), %rdi     # 0x272cc
leaq 0x21e02(%rip), %rsi     # 0x27561
movl $0x23a, %edx            # imm = 0x23A
leaq 0x21d22(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x5782
cmpq $0x0, -0x10(%rbp)
jne 0x5794
leaq 0x23fbc(%rip), %rax     # 0x2974c
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x57c0
cmpl $0x0, %eax
je 0x57ac
jmp 0x57ac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_do_set_netmask
static int
netif_do_set_netmask(struct netif *netif, const ip4_addr_t *netmask, ip_addr_t *old_nm)
{
  /* address is actually being changed? */
  if (ip4_addr_cmp(netmask, netif_ip4_netmask(netif)) == 0) {
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    LWIP_ASSERT("invalid pointer", old_nm != NULL);
    ip_addr_copy(*old_nm, *netif_ip_netmask4(netif));
#else
    LWIP_UNUSED_ARG(old_nm);
#endif
    mib2_remove_route_ip4(0, netif);
    /* set new netmask to netif */
    ip4_addr_set(ip_2_ip4(&netif->netmask), netmask);
    IP_SET_TYPE_VAL(netif->netmask, IPADDR_TYPE_V4);
    mib2_add_route_ip4(0, netif);
    LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: netmask of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
                netif->name[0], netif->name[1],
                ip4_addr1_16(netif_ip4_netmask(netif)),
                ip4_addr2_16(netif_ip4_netmask(netif)),
                ip4_addr3_16(netif_ip4_netmask(netif)),
                ip4_addr4_16(netif_ip4_netmask(netif))));
    return 1; /* netmask changed */
  }
  return 0; /* netmask unchanged */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5820
cmpq $0x0, -0x18(%rbp)
jne 0x57f8
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x5801
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x34(%rax)
jmp 0x5815
jmp 0x5817
movl $0x1, -0x4(%rbp)
jmp 0x5827
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_set_gw
void
netif_set_gw(struct netif *netif, const ip4_addr_t *gw)
{
#if LWIP_NETIF_EXT_STATUS_CALLBACK
  ip_addr_t old_gw_val;
  ip_addr_t *old_gw = &old_gw_val;
#else
  ip_addr_t *old_gw = NULL;
#endif
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_gw: invalid netif", netif != NULL, return);

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */
  if (gw == NULL) {
    gw = IP4_ADDR_ANY4;
  }

  if (netif_do_set_gw(netif, gw, old_gw)) {
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    netif_ext_callback_args_t args;
    args.ipv4_changed.old_gw = old_gw;
    netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_GATEWAY_CHANGED, &args);
#endif
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5880
jmp 0x5851
leaq 0x21a74(%rip), %rdi     # 0x272cc
leaq 0x21d23(%rip), %rsi     # 0x27582
movl $0x277, %edx            # imm = 0x277
leaq 0x21c22(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x5882
cmpq $0x0, -0x10(%rbp)
jne 0x5894
leaq 0x23ebc(%rip), %rax     # 0x2974c
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x58c0
cmpl $0x0, %eax
je 0x58ac
jmp 0x58ac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_do_set_gw
static int
netif_do_set_gw(struct netif *netif, const ip4_addr_t *gw, ip_addr_t *old_gw)
{
  /* address is actually being changed? */
  if (ip4_addr_cmp(gw, netif_ip4_gw(netif)) == 0) {
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    LWIP_ASSERT("invalid pointer", old_gw != NULL);
    ip_addr_copy(*old_gw, *netif_ip_gw4(netif));
#else
    LWIP_UNUSED_ARG(old_gw);
#endif

    ip4_addr_set(ip_2_ip4(&netif->gw), gw);
    IP_SET_TYPE_VAL(netif->gw, IPADDR_TYPE_V4);
    LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: GW address of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
                netif->name[0], netif->name[1],
                ip4_addr1_16(netif_ip4_gw(netif)),
                ip4_addr2_16(netif_ip4_gw(netif)),
                ip4_addr3_16(netif_ip4_gw(netif)),
                ip4_addr4_16(netif_ip4_gw(netif))));
    return 1; /* gateway changed */
  }
  return 0; /* gateway unchanged */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x38(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5920
cmpq $0x0, -0x18(%rbp)
jne 0x58f8
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x5901
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x4c(%rax)
jmp 0x5915
jmp 0x5917
movl $0x1, -0x4(%rbp)
jmp 0x5927
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_set_down
void
netif_set_down(struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_down: invalid netif", netif != NULL, return);

  if (netif->flags & NETIF_FLAG_UP) {
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    {
      netif_ext_callback_args_t args;
      args.status_changed.state = 0;
      netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args);
    }
#endif

    netif_clear_flags(netif, NETIF_FLAG_UP);
    MIB2_COPY_SYSUPTIME_TO(&netif->ts);

#if LWIP_IPV4 && LWIP_ARP
    if (netif->flags & NETIF_FLAG_ETHARP) {
      etharp_cleanup_netif(netif);
    }
#endif /* LWIP_IPV4 && LWIP_ARP */

#if LWIP_IPV6
    nd6_cleanup_netif(netif);
#endif /* LWIP_IPV6 */

    NETIF_STATUS_CALLBACK(netif);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5af4
jmp 0x5ac5
leaq 0x21800(%rip), %rdi     # 0x272cc
leaq 0x21ae7(%rip), %rsi     # 0x275ba
movl $0x39b, %edx            # imm = 0x39B
leaq 0x219ae(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x5af6
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5b30
jmp 0x5b0b
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
andl $0xfe, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xeb(%rax)
movq -0x8(%rbp), %rdi
callq 0x24c40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_issue_reports
static void
netif_issue_reports(struct netif *netif, u8_t report_type)
{
  LWIP_ASSERT("netif_issue_reports: invalid netif", netif != NULL);

  /* Only send reports when both link and admin states are up */
  if (!(netif->flags & NETIF_FLAG_LINK_UP) ||
      !(netif->flags & NETIF_FLAG_UP)) {
    return;
  }

#if LWIP_IPV4
  if ((report_type & NETIF_REPORT_TYPE_IPV4) &&
      !ip4_addr_isany_val(*netif_ip4_addr(netif))) {
#if LWIP_ARP
    /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */
    if (netif->flags & (NETIF_FLAG_ETHARP)) {
      etharp_gratuitous(netif);
    }
#endif /* LWIP_ARP */

#if LWIP_IGMP
    /* resend IGMP memberships */
    if (netif->flags & NETIF_FLAG_IGMP) {
      igmp_report_groups(netif);
    }
#endif /* LWIP_IGMP */
  }
#endif /* LWIP_IPV4 */

#if LWIP_IPV6
  if (report_type & NETIF_REPORT_TYPE_IPV6) {
#if LWIP_IPV6_MLD
    /* send mld memberships */
    mld6_report_groups(netif);
#endif /* LWIP_IPV6_MLD */
  }
#endif /* LWIP_IPV6 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5bba
jmp 0x5b8b
leaq 0x2173a(%rip), %rdi     # 0x272cc
leaq 0x21cc0(%rip), %rsi     # 0x27859
movl $0x36d, %edx            # imm = 0x36D
leaq 0x218e8(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x5bbc
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5be2
movq -0x8(%rbp), %rax
movzbl 0xeb(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5be4
jmp 0x5c0a
movzbl -0x9(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5bfc
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5bfc
jmp 0x5bfc
movzbl -0x9(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5c0a
jmp 0x5c0a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_ip6_addr_set
void
netif_ip6_addr_set(struct netif *netif, s8_t addr_idx, const ip6_addr_t *addr6)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ASSERT("netif_ip6_addr_set: invalid netif", netif != NULL);
  LWIP_ASSERT("netif_ip6_addr_set: invalid addr6", addr6 != NULL);

  netif_ip6_addr_set_parts(netif, addr_idx, addr6->addr[0], addr6->addr[1],
                           addr6->addr[2], addr6->addr[3]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x605e
jmp 0x602f
leaq 0x21296(%rip), %rdi     # 0x272cc
leaq 0x216bb(%rip), %rsi     # 0x276f8
movl $0x526, %edx            # imm = 0x526
leaq 0x21444(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x6060
jmp 0x6062
cmpq $0x0, -0x18(%rbp)
jne 0x609a
jmp 0x606b
leaq 0x2125a(%rip), %rdi     # 0x272cc
leaq 0x216a1(%rip), %rsi     # 0x2771a
movl $0x527, %edx            # imm = 0x527
leaq 0x21408(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x609c
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rsi
movl 0x8(%rsi), %r8d
movq -0x18(%rbp), %rsi
movl 0xc(%rsi), %r9d
movsbl %al, %esi
callq 0x60d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_get_ip6_addr_match
s8_t
netif_get_ip6_addr_match(struct netif *netif, const ip6_addr_t *ip6addr)
{
  s8_t i;

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ASSERT("netif_get_ip6_addr_match: invalid netif", netif != NULL);
  LWIP_ASSERT("netif_get_ip6_addr_match: invalid ip6addr", ip6addr != NULL);

#if LWIP_IPV6_SCOPES
  if (ip6_addr_has_zone(ip6addr) && !ip6_addr_test_zone(ip6addr, netif)) {
    return -1; /* wrong zone, no match */
  }
#endif /* LWIP_IPV6_SCOPES */

  for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
    if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i)) &&
        ip6_addr_cmp_zoneless(netif_ip6_addr(netif, i), ip6addr)) {
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x65b8
jmp 0x6589
leaq 0x20d3c(%rip), %rdi     # 0x272cc
leaq 0x211c1(%rip), %rsi     # 0x27758
movl $0x5be, %edx            # imm = 0x5BE
leaq 0x20eea(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x65ba
jmp 0x65bc
cmpq $0x0, -0x18(%rbp)
jne 0x65f4
jmp 0x65c5
leaq 0x20d00(%rip), %rdi     # 0x272cc
leaq 0x211ad(%rip), %rsi     # 0x27780
movl $0x5bf, %edx            # imm = 0x5BF
leaq 0x20eae(%rip), %rcx     # 0x2748d
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x65f6
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x6629
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0xee(%rcx), %ecx
addl $0x1, %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x6629
movb $-0x1, -0x1(%rbp)
jmp 0x66ed
movb $0x0, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x3, %eax
jge 0x66e9
movq -0x10(%rbp), %rax
movsbq -0x19(%rbp), %rcx
movzbl 0x98(%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x66da
movq -0x10(%rbp), %rax
addq $0x50, %rax
movsbq -0x19(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x66da
movq -0x10(%rbp), %rax
addq $0x50, %rax
movsbq -0x19(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x66da
movq -0x10(%rbp), %rax
addq $0x50, %rax
movsbq -0x19(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x66da
movq -0x10(%rbp), %rax
addq $0x50, %rax
movsbq -0x19(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x66da
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x66ed
jmp 0x66dc
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x662d
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_name_to_index
u8_t
netif_name_to_index(const char *name)
{
  struct netif *netif = netif_find(name);
  if (netif != NULL) {
    return netif_get_index(netif);
  }
  /* No name found, return invalid index */
  return NETIF_NO_INDEX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ba3
movq -0x18(%rbp), %rax
movzbl 0xee(%rax), %eax
addl $0x1, %eax
movb %al, -0x1(%rbp)
jmp 0x6ba7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq