LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/netif.c
// Function: netif_find
struct netif *
netif_find(const char *name)
{
  struct netif *netif;
  u8_t num;

  LWIP_ASSERT_CORE_LOCKED();

  if (name == NULL) {
    return NULL;
  }

  num = (u8_t)atoi(&name[2]);

  NETIF_FOREACH(netif) {
    if (num == netif->num &&
        name[0] == netif->name[0] &&
        name[1] == netif->name[1]) {
      LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1]));
      return netif;
    }
  }
  LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: didn't find %c%c\n", name[0], name[1]));
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6bd0
movq $0x0, -0x8(%rbp)
jmp 0x6c5b
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
callq 0x21f0
movb %al, -0x19(%rbp)
movq 0x28cf1(%rip), %rax     # 0x2f8d8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6c4f
movzbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0xee(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6c40
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0xec(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6c40
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0xed(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6c40
jmp 0x6c34
jmp 0x6c36
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c5b
jmp 0x6c42
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6beb
jmp 0x6c51
jmp 0x6c53
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_index_to_name
char *
netif_index_to_name(u8_t idx, char *name)
{
  struct netif *netif = netif_get_by_index(idx);

  if (netif != NULL) {
    name[0] = netif->name[0];
    name[1] = netif->name[1];
    lwip_itoa(&name[2], NETIF_NAMESIZE - 2, netif_index_to_num(idx));
    return name;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movzbl -0x9(%rbp), %edi
callq 0x6cf0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6cda
movq -0x20(%rbp), %rax
movb 0xec(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movb 0xed(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
movzbl -0x9(%rbp), %edx
subl $0x1, %edx
movl $0x4, %esi
callq 0x25480
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6ce2
movq $0x0, -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/netif.c
// Function: netif_get_by_index
struct netif *
netif_get_by_index(u8_t idx)
{
  struct netif *netif;

  LWIP_ASSERT_CORE_LOCKED();

  if (idx != NETIF_NO_INDEX) {
    NETIF_FOREACH(netif) {
      if (idx == netif_get_index(netif)) {
        return netif; /* found! */
      }
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x6d49
movq 0x28bce(%rip), %rax     # 0x2f8d8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6d47
movzbl -0x9(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0xee(%rcx), %ecx
addl $0x1, %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x6d38
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d51
jmp 0x6d3a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6d0e
jmp 0x6d49
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_free_ooseq
void
pbuf_free_ooseq(void)
{
  struct tcp_pcb *pcb;
  SYS_ARCH_SET(pbuf_free_ooseq_pending, 0);

  for (pcb = tcp_active_pcbs; NULL != pcb; pcb = pcb->next) {
    if (pcb->ooseq != NULL) {
      /** Free the ooseq pbufs of one PCB only */
      LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free_ooseq: freeing out-of-sequence pbufs\n"));
      tcp_free_ooseq(pcb);
      return;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, 0x28b19(%rip)     # 0x2f8e8
leaq 0x28b32(%rip), %rax     # 0x2f908
movq (%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x6e12
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x6e02
jmp 0x6df5
jmp 0x6df7
movq -0x8(%rbp), %rdi
callq 0xd270
jmp 0x6e12
jmp 0x6e04
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6ddd
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/pbuf.c
// Function: pbuf_alloc_reference
struct pbuf *
pbuf_alloc_reference(void *payload, u16_t length, pbuf_type type)
{
  struct pbuf *p;
  LWIP_ASSERT("invalid pbuf_type", (type == PBUF_REF) || (type == PBUF_ROM));
  /* only allocate memory for the pbuf structure */
  p = (struct pbuf *)memp_malloc(MEMP_PBUF);
  if (p == NULL) {
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
                ("pbuf_alloc_reference: Could not allocate MEMP_PBUF for PBUF_%s.\n",
                 (type == PBUF_ROM) ? "ROM" : "REF"));
    return NULL;
  }
  pbuf_init_alloced_pbuf(p, payload, length, length, type, 0);
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x41, -0x18(%rbp)
je 0x71f3
cmpl $0x1, -0x18(%rbp)
je 0x71f3
jmp 0x71c4
leaq 0x20101(%rip), %rdi     # 0x272cc
leaq 0x2076c(%rip), %rsi     # 0x2793e
movl $0x14a, %edx            # imm = 0x14A
leaq 0x206cb(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x71f5
movl $0xa, %edi
callq 0x4930
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7218
jmp 0x720c
jmp 0x720e
movq $0x0, -0x8(%rbp)
jmp 0x7242
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movw -0x12(%rbp), %cx
movw -0x12(%rbp), %ax
movl -0x18(%rbp), %r8d
xorl %r9d, %r9d
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x7460
movq -0x20(%rbp), %rax
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/pbuf.c
// Function: pbuf_init_alloced_pbuf
static void
pbuf_init_alloced_pbuf(struct pbuf *p, void *payload, u16_t tot_len, u16_t len, pbuf_type type, u8_t flags)
{
  p->next = NULL;
  p->payload = payload;
  p->tot_len = tot_len;
  p->len = len;
  p->type_internal = (u8_t)type;
  p->flags = flags;
  p->ref = 1;
  p->if_idx = NETIF_NO_INDEX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %dx, -0x12(%rbp)
movw %cx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movw -0x12(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x10(%rax)
movw -0x14(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x12(%rax)
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x14(%rax)
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x15(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x16(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x17(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_alloced_custom
struct pbuf *
pbuf_alloced_custom(pbuf_layer l, u16_t length, pbuf_type type, struct pbuf_custom *p,
                    void *payload_mem, u16_t payload_mem_len)
{
  u16_t offset = (u16_t)l;
  void *payload;
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloced_custom(length=%"U16_F")\n", length));

  if (LWIP_MEM_ALIGN_SIZE(offset) + length > payload_mem_len) {
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_WARNING, ("pbuf_alloced_custom(length=%"U16_F") buffer too short\n", length));
    return NULL;
  }

  if (payload_mem != NULL) {
    payload = (u8_t *)payload_mem + LWIP_MEM_ALIGN_SIZE(offset);
  } else {
    payload = NULL;
  }
  pbuf_init_alloced_pbuf(&p->pbuf, payload, length, length, type, PBUF_FLAG_IS_CUSTOM);
  return &p->pbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %r9w, %ax
movl %edi, -0xc(%rbp)
movw %si, -0xe(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movw %ax, -0x2a(%rbp)
movl -0xc(%rbp), %eax
movw %ax, -0x2c(%rbp)
jmp 0x750b
movzwl -0x2c(%rbp), %eax
addl $0x1, %eax
subl $0x1, %eax
andl $-0x1, %eax
movzwl -0xe(%rbp), %ecx
addl %ecx, %eax
movzwl -0x2a(%rbp), %ecx
cmpl %ecx, %eax
jbe 0x7534
jmp 0x7528
jmp 0x752a
movq $0x0, -0x8(%rbp)
jmp 0x758c
cmpq $0x0, -0x28(%rbp)
je 0x7557
movq -0x28(%rbp), %rax
movzwl -0x2c(%rbp), %ecx
addl $0x1, %ecx
subl $0x1, %ecx
andl $-0x1, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x755f
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movw -0xe(%rbp), %cx
movw -0xe(%rbp), %ax
movl -0x14(%rbp), %r8d
movl $0x2, %r9d
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x7460
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %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/pbuf.c
// Function: pbuf_remove_header
u8_t
pbuf_remove_header(struct pbuf *p, size_t header_size_decrement)
{
  void *payload;
  u16_t increment_magnitude;

  LWIP_ASSERT("p != NULL", p != NULL);
  if ((p == NULL) || (header_size_decrement > 0xFFFF)) {
    return 1;
  }
  if (header_size_decrement == 0) {
    return 0;
  }

  increment_magnitude = (u16_t)header_size_decrement;
  /* Check that we aren't going to move off the end of the pbuf */
  LWIP_ERROR("increment_magnitude <= p->len", (increment_magnitude <= p->len), return 1;);

  /* remember current payload pointer */
  payload = p->payload;
  LWIP_UNUSED_ARG(payload); /* only used in LWIP_DEBUGF below */

  /* increase payload pointer (guarded by length check above) */
  p->payload = (u8_t *)p->payload + header_size_decrement;
  /* modify pbuf length fields */
  p->len = (u16_t)(p->len - increment_magnitude);
  p->tot_len = (u16_t)(p->tot_len - increment_magnitude);

  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_remove_header: old %p new %p (%"U16_F")\n",
              (void *)payload, (void *)p->payload, increment_magnitude));

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7998
jmp 0x7969
leaq 0x1f95c(%rip), %rdi     # 0x272cc
leaq 0x1ffe7(%rip), %rsi     # 0x2795e
movl $0x24b, %edx            # imm = 0x24B
leaq 0x1ff26(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x799a
cmpq $0x0, -0x10(%rbp)
je 0x79ab
cmpq $0xffff, -0x18(%rbp)    # imm = 0xFFFF
jbe 0x79b4
movb $0x1, -0x1(%rbp)
jmp 0x7a67
cmpq $0x0, -0x18(%rbp)
jne 0x79c4
movb $0x0, -0x1(%rbp)
jmp 0x7a67
movq -0x18(%rbp), %rax
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jle 0x7a0d
jmp 0x79de
leaq 0x1f8e7(%rip), %rdi     # 0x272cc
leaq 0x1ffb0(%rip), %rsi     # 0x2799c
movl $0x255, %edx            # imm = 0x255
leaq 0x1feb1(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x7a0f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x22(%rbp), %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x12(%rax)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
movzwl -0x22(%rbp), %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
jmp 0x7a63
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_free_header
struct pbuf *
pbuf_free_header(struct pbuf *q, u16_t size)
{
  struct pbuf *p = q;
  u16_t free_left = size;
  while (free_left && p) {
    if (free_left >= p->len) {
      struct pbuf *f = p;
      free_left = (u16_t)(free_left - p->len);
      p = p->next;
      f->next = 0;
      pbuf_free(f);
    } else {
      pbuf_remove_header(p, free_left);
      free_left = 0;
    }
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x7b6c
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7b75
jmp 0x7bda
movzwl -0x1a(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jl 0x7bc0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movzwl -0x1a(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
subl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x7bd5
movq -0x18(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
movl %eax, %esi
callq 0x7950
movw $0x0, -0x1a(%rbp)
jmp 0x7b53
movq -0x18(%rbp), %rax
addq $0x30, %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/pbuf.c
// Function: pbuf_clen
u16_t
pbuf_clen(const struct pbuf *p)
{
  u16_t len;

  len = 0;
  while (p != NULL) {
    ++len;
    p = p->next;
  }
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xa(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7c1e
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7bfe
movw -0xa(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_cat
void
pbuf_cat(struct pbuf *h, struct pbuf *t)
{
  struct pbuf *p;

  LWIP_ERROR("(h != NULL) && (t != NULL) (programmer violates API)",
             ((h != NULL) && (t != NULL)), return;);

  /* proceed to last pbuf of chain */
  for (p = h; p->next != NULL; p = p->next) {
    /* add total length of second chain to all totals of first chain */
    p->tot_len = (u16_t)(p->tot_len + t->tot_len);
  }
  /* { p is last pbuf of first h chain, p->next == NULL } */
  LWIP_ASSERT("p->tot_len == p->len (of last pbuf in chain)", p->tot_len == p->len);
  LWIP_ASSERT("p->next == NULL", p->next == NULL);
  /* add total length of second chain to last pbuf total of first chain */
  p->tot_len = (u16_t)(p->tot_len + t->tot_len);
  /* chain last pbuf of head (p) with first of tail (t) */
  p->next = t;
  /* p->next now references t, but the caller will drop its reference to t,
   * so netto there is no change to the reference count of t.
   */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7cce
cmpq $0x0, -0x10(%rbp)
jne 0x7cff
jmp 0x7cd0
leaq 0x1f5f5(%rip), %rdi     # 0x272cc
leaq 0x1fd37(%rip), %rsi     # 0x27a15
movl $0x35a, %edx            # imm = 0x35A
leaq 0x1fbbf(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x7d01
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7d3d
movq -0x18(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7d09
jmp 0x7d3f
movq -0x18(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
cmpl %ecx, %eax
je 0x7d84
jmp 0x7d55
leaq 0x1f570(%rip), %rdi     # 0x272cc
leaq 0x1fce7(%rip), %rsi     # 0x27a4a
movl $0x362, %edx            # imm = 0x362
leaq 0x1fb3a(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x7d86
jmp 0x7d88
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7dc3
jmp 0x7d94
leaq 0x1f531(%rip), %rdi     # 0x272cc
leaq 0x1fcd5(%rip), %rsi     # 0x27a77
movl $0x363, %edx            # imm = 0x363
leaq 0x1fafb(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x7dc5
movq -0x18(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
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/pbuf.c
// Function: pbuf_dechain
struct pbuf *
pbuf_dechain(struct pbuf *p)
{
  struct pbuf *q;
  u8_t tail_gone = 1;
  /* tail */
  q = p->next;
  /* pbuf has successor in chain? */
  if (q != NULL) {
    /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */
    LWIP_ASSERT("p->tot_len == p->len + q->tot_len", q->tot_len == p->tot_len - p->len);
    /* enforce invariant if assertion is disabled */
    q->tot_len = (u16_t)(p->tot_len - p->len);
    /* decouple pbuf from remainder */
    p->next = NULL;
    /* total length of pbuf p is its own length only */
    p->tot_len = p->len;
    /* q is no longer referenced by p, free it */
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_dechain: unreferencing %p\n", (void *)q));
    tail_gone = pbuf_free(q);
    if (tail_gone > 0) {
      LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE,
                  ("pbuf_dechain: deallocated %p (as it is no longer referenced)\n", (void *)q));
    }
    /* return remaining tail or NULL if deallocated */
  }
  /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */
  LWIP_ASSERT("p->tot_len == p->len", p->tot_len == p->len);
  return ((tail_gone > 0) ? NULL : q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7f00
jmp 0x7e58
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x12(%rdx), %edx
subl %edx, %ecx
cmpl %ecx, %eax
je 0x7ea7
jmp 0x7e78
leaq 0x1f44d(%rip), %rdi     # 0x272cc
leaq 0x1fc01(%rip), %rsi     # 0x27a87
movl $0x399, %edx            # imm = 0x399
leaq 0x1fa17(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x7ea9
movq -0x8(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movw 0x12(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x10(%rax)
jmp 0x7ee3
movq -0x10(%rbp), %rdi
callq 0x7260
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jle 0x7efe
jmp 0x7efa
jmp 0x7efc
jmp 0x7efe
jmp 0x7f00
jmp 0x7f02
movq -0x8(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
cmpl %ecx, %eax
je 0x7f47
jmp 0x7f18
leaq 0x1f3ad(%rip), %rdi     # 0x272cc
leaq 0x1fb83(%rip), %rsi     # 0x27aa9
movl $0x3aa, %edx            # imm = 0x3AA
leaq 0x1f977(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x7f49
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jle 0x7f5a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x7f62
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%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/pbuf.c
// Function: pbuf_get_contiguous
void *
pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset)
{
  const struct pbuf *q;
  u16_t out_offset;

  LWIP_ERROR("pbuf_get_contiguous: invalid buf", (p != NULL), return NULL;);
  LWIP_ERROR("pbuf_get_contiguous: invalid dataptr", (buffer != NULL), return NULL;);
  LWIP_ERROR("pbuf_get_contiguous: invalid dataptr", (bufsize >= len), return NULL;);

  q = pbuf_skip_const(p, offset, &out_offset);
  if (q != NULL) {
    if (q->len >= (out_offset + len)) {
      /* all data in this pbuf, return zero-copy */
      return (u8_t *)q->payload + out_offset;
    }
    /* need to copy */
    if (pbuf_copy_partial(q, buffer, len, out_offset) != len) {
      /* copying failed: pbuf is too short */
      return NULL;
    }
    return buffer;
  }
  /* pbuf is too short (offset does not fit in) */
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %r8w, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movw %cx, -0x22(%rbp)
movw %ax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8448
jmp 0x8419
leaq 0x1eeac(%rip), %rdi     # 0x272cc
leaq 0x1f772(%rip), %rsi     # 0x27b99
movl $0x437, %edx            # imm = 0x437
leaq 0x1f476(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x844a
jmp 0x844c
cmpq $0x0, -0x18(%rbp)
jne 0x8484
jmp 0x8455
leaq 0x1ee70(%rip), %rdi     # 0x272cc
leaq 0x1f757(%rip), %rsi     # 0x27bba
movl $0x438, %edx            # imm = 0x438
leaq 0x1f43a(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x8486
jmp 0x8488
movq -0x20(%rbp), %rax
movzwl -0x22(%rbp), %ecx
cmpq %rcx, %rax
jae 0x84c6
jmp 0x8497
leaq 0x1ee2e(%rip), %rdi     # 0x272cc
leaq 0x1f715(%rip), %rsi     # 0x27bba
movl $0x439, %edx            # imm = 0x439
leaq 0x1f3f8(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x84c8
movq -0x10(%rbp), %rdi
leaq -0x32(%rbp), %rdx
movzwl -0x24(%rbp), %esi
callq 0x8560
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8549
movq -0x30(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x32(%rbp), %ecx
movzwl -0x22(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x8512
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0x32(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8551
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movw -0x22(%rbp), %ax
movzwl %ax, %edx
movzwl -0x32(%rbp), %ecx
callq 0x8250
movzwl %ax, %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
je 0x853f
movq $0x0, -0x8(%rbp)
jmp 0x8551
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8551
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_skip_const
static const struct pbuf *
pbuf_skip_const(const struct pbuf *in, u16_t in_offset, u16_t *out_offset)
{
  u16_t offset_left = in_offset;
  const struct pbuf *q = in;

  /* get the correct pbuf */
  while ((q != NULL) && (q->len <= offset_left)) {
    offset_left = (u16_t)(offset_left - q->len);
    q = q->next;
  }
  if (out_offset != NULL) {
    *out_offset = offset_left;
  }
  return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x85a3
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x85ac
jmp 0x85cb
movzwl -0x1a(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
subl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8583
cmpq $0x0, -0x18(%rbp)
je 0x85dd
movw -0x1a(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_take_at
err_t
pbuf_take_at(struct pbuf *buf, const void *dataptr, u16_t len, u16_t offset)
{
  u16_t target_offset;
  struct pbuf *q = pbuf_skip(buf, offset, &target_offset);

  /* return requested data if pbuf is OK */
  if ((q != NULL) && (q->tot_len >= target_offset + len)) {
    u16_t remaining_len = len;
    const u8_t *src_ptr = (const u8_t *)dataptr;
    /* copy the part that goes into the first pbuf */
    u16_t first_copy_len;
    LWIP_ASSERT("check pbuf_skip result", target_offset < q->len);
    first_copy_len = (u16_t)LWIP_MIN(q->len - target_offset, len);
    MEMCPY(((u8_t *)q->payload) + target_offset, dataptr, first_copy_len);
    remaining_len = (u16_t)(remaining_len - first_copy_len);
    src_ptr += first_copy_len;
    if (remaining_len > 0) {
      return pbuf_take(q->next, src_ptr, remaining_len);
    }
    return ERR_OK;
  }
  return ERR_MEM;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movw %ax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1e(%rbp), %rdx
movzwl -0x1c(%rbp), %esi
callq 0x85f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x899a
movq -0x28(%rbp), %rax
movzwl 0x10(%rax), %eax
movzwl -0x1e(%rbp), %ecx
movzwl -0x1a(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x899a
movw -0x1a(%rbp), %ax
movw %ax, -0x2a(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movzwl -0x1e(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jl 0x88f9
jmp 0x88ca
leaq 0x1e9fb(%rip), %rdi     # 0x272cc
leaq 0x1f387(%rip), %rsi     # 0x27c5f
movl $0x4e3, %edx            # imm = 0x4E3
leaq 0x1efc5(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x88fb
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x1e(%rbp), %ecx
subl %ecx, %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x8924
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x1e(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x40(%rbp)
jmp 0x892b
movzwl -0x1a(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movw %ax, -0x3a(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0x1e(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movzwl -0x3a(%rbp), %eax
movl %eax, %edx
callq 0x2180
movzwl -0x2a(%rbp), %eax
movzwl -0x3a(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x2a(%rbp)
movzwl -0x3a(%rbp), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movzwl -0x2a(%rbp), %eax
cmpl $0x0, %eax
jle 0x8994
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movzwl -0x2a(%rbp), %edx
callq 0x8630
movb %al, -0x1(%rbp)
jmp 0x899e
movb $0x0, -0x1(%rbp)
jmp 0x899e
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_coalesce
struct pbuf *
pbuf_coalesce(struct pbuf *p, pbuf_layer layer)
{
  struct pbuf *q;
  if (p->next == NULL) {
    return p;
  }
  q = pbuf_clone(layer, PBUF_RAM, p);
  if (q == NULL) {
    /* @todo: what do we do now? */
    return p;
  }
  pbuf_free(p);
  return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x89d3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a0a
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x280, %esi            # imm = 0x280
callq 0x8a20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x89f9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a0a
movq -0x10(%rbp), %rdi
callq 0x7260
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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/pbuf.c
// Function: pbuf_clone
struct pbuf *
pbuf_clone(pbuf_layer layer, pbuf_type type, struct pbuf *p)
{
  struct pbuf *q;
  err_t err;
  q = pbuf_alloc(layer, p->tot_len, type);
  if (q == NULL) {
    return NULL;
  }
  err = pbuf_copy(q, p);
  LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */
  LWIP_ASSERT("pbuf_copy failed", err == ERR_OK);
  return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movw 0x10(%rax), %ax
movl -0x10(%rbp), %edx
movzwl %ax, %esi
callq 0x6e20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8a5d
movq $0x0, -0x8(%rbp)
jmp 0x8ab1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7f70
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x8aa7
jmp 0x8a78
leaq 0x1e84d(%rip), %rdi     # 0x272cc
leaq 0x1f1f0(%rip), %rsi     # 0x27c76
movl $0x524, %edx            # imm = 0x524
leaq 0x1ee17(%rip), %rcx     # 0x278a9
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0x8aa9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_get_at
u8_t
pbuf_get_at(const struct pbuf *p, u16_t offset)
{
  int ret = pbuf_try_get_at(p, offset);
  if (ret >= 0) {
    return (u8_t)ret;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x8ce0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x8cd1
movl -0x18(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0x8cd5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_try_get_at
int
pbuf_try_get_at(const struct pbuf *p, u16_t offset)
{
  u16_t q_idx;
  const struct pbuf *q = pbuf_skip_const(p, offset, &q_idx);

  /* return requested data if pbuf is OK */
  if ((q != NULL) && (q->len > q_idx)) {
    return ((u8_t *)q->payload)[q_idx];
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rdx
movzwl -0x12(%rbp), %esi
callq 0x8560
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8d34
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jle 0x8d34
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x8d3b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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/pbuf.c
// Function: pbuf_memcmp
u16_t
pbuf_memcmp(const struct pbuf *p, u16_t offset, const void *s2, u16_t n)
{
  u16_t start = offset;
  const struct pbuf *q = p;
  u16_t i;

  /* pbuf long enough to perform check? */
  if (p->tot_len < (offset + n)) {
    return 0xffff;
  }

  /* get the correct pbuf from chain. We know it succeeds because of p->tot_len check above. */
  while ((q != NULL) && (q->len <= start)) {
    start = (u16_t)(start - q->len);
    q = q->next;
  }

  /* return requested data if pbuf is OK */
  for (i = 0; i < n; i++) {
    /* We know pbuf_get_at() succeeds because of p->tot_len check above. */
    u8_t a = pbuf_get_at(q, (u16_t)(start + i));
    u8_t b = ((const u8_t *)s2)[i];
    if (a != b) {
      return (u16_t)LWIP_MIN(i + 1, 0xFFFF);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movw -0x12(%rbp), %ax
movw %ax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
movzwl -0x12(%rbp), %ecx
movzwl -0x22(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x8dff
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x8ed1
jmp 0x8e01
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x35(%rbp)
je 0x8e21
movq -0x30(%rbp), %rax
movzwl 0x12(%rax), %eax
movzwl -0x24(%rbp), %ecx
cmpl %ecx, %eax
setle %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x8e2a
jmp 0x8e49
movzwl -0x24(%rbp), %eax
movq -0x30(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
subl %ecx, %eax
movw %ax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x8e01
movw $0x0, -0x32(%rbp)
movzwl -0x32(%rbp), %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jge 0x8ecb
movq -0x30(%rbp), %rdi
movzwl -0x24(%rbp), %eax
movzwl -0x32(%rbp), %ecx
addl %ecx, %eax
movzwl %ax, %esi
callq 0x8ca0
movb %al, -0x33(%rbp)
movq -0x20(%rbp), %rax
movzwl -0x32(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x34(%rbp)
movzbl -0x33(%rbp), %eax
movzbl -0x34(%rbp), %ecx
cmpl %ecx, %eax
je 0x8ebb
movzwl -0x32(%rbp), %eax
addl $0x1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jge 0x8ea8
movzwl -0x32(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8eb2
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x3c(%rbp)
jmp 0x8eb2
movl -0x3c(%rbp), %eax
movw %ax, -0x2(%rbp)
jmp 0x8ed1
jmp 0x8ebd
movw -0x32(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x32(%rbp)
jmp 0x8e4f
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_memfind
u16_t
pbuf_memfind(const struct pbuf *p, const void *mem, u16_t mem_len, u16_t start_offset)
{
  u16_t i;
  u16_t max_cmp_start = (u16_t)(p->tot_len - mem_len);
  if (p->tot_len >= mem_len + start_offset) {
    for (i = start_offset; i <= max_cmp_start; i++) {
      u16_t plus = pbuf_memcmp(p, i, mem, mem_len);
      if (plus == 0) {
        return i;
      }
    }
  }
  return 0xFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movw %ax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
movzwl -0x1a(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
movzwl -0x1a(%rbp), %ecx
movzwl -0x1c(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x8f7b
movw -0x1c(%rbp), %ax
movw %ax, -0x1e(%rbp)
movzwl -0x1e(%rbp), %eax
movzwl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jg 0x8f79
movq -0x10(%rbp), %rdi
movw -0x1e(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
movzwl -0x1a(%rbp), %ecx
callq 0x8db0
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
cmpl $0x0, %eax
jne 0x8f69
movw -0x1e(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x8f81
jmp 0x8f6b
movw -0x1e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1e(%rbp)
jmp 0x8f2e
jmp 0x8f7b
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/pbuf.c
// Function: pbuf_strstr
u16_t
pbuf_strstr(const struct pbuf *p, const char *substr)
{
  size_t substr_len;
  if ((substr == NULL) || (substr[0] == 0) || (p->tot_len == 0xFFFF)) {
    return 0xFFFF;
  }
  substr_len = strlen(substr);
  if (substr_len >= 0xFFFF) {
    return 0xFFFF;
  }
  return pbuf_memfind(p, substr, (u16_t)substr_len, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8fc2
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x8fc2
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x8fca
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x9003
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x20(%rbp)
cmpq $0xffff, -0x20(%rbp)    # imm = 0xFFFF
jb 0x8fe9
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x9003
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movzwl %ax, %edx
callq 0x8ee0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
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/raw.c
// Function: raw_bind_netif
void
raw_bind_netif(struct raw_pcb *pcb, const struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();
  if (netif != NULL) {
    pcb->netif_idx = netif_get_index(netif);
  } else {
    pcb->netif_idx = NETIF_NO_INDEX;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x976c
movq -0x10(%rbp), %rax
movzbl 0xee(%rax), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x30(%rax)
jmp 0x9774
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/raw.c
// Function: raw_remove
void
raw_remove(struct raw_pcb *pcb)
{
  struct raw_pcb *pcb2;
  LWIP_ASSERT_CORE_LOCKED();
  /* pcb to be removed is first in list? */
  if (raw_pcbs == pcb) {
    /* make list start at 2nd pcb */
    raw_pcbs = raw_pcbs->next;
    /* pcb not 1st in list */
  } else {
    for (pcb2 = raw_pcbs; pcb2 != NULL; pcb2 = pcb2->next) {
      /* find pcb in raw_pcbs list */
      if (pcb2->next != NULL && pcb2->next == pcb) {
        /* remove pcb from list */
        pcb2->next = pcb->next;
        break;
      }
    }
  }
  memp_free(MEMP_RAW_PCB, pcb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2569d(%rip), %rax     # 0x2f8f0
cmpq -0x8(%rbp), %rax
jne 0xa26d
movq 0x25690(%rip), %rax     # 0x2f8f0
movq 0x38(%rax), %rax
movq %rax, 0x25685(%rip)     # 0x2f8f0
jmp 0xa2bc
movq 0x2567c(%rip), %rax     # 0x2f8f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa2ba
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xa2aa
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xa2aa
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xa2ba
jmp 0xa2ac
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa278
jmp 0xa2bc
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x4a80
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/raw.c
// Function: raw_new
struct raw_pcb *
raw_new(u8_t proto)
{
  struct raw_pcb *pcb;

  LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE, ("raw_new\n"));
  LWIP_ASSERT_CORE_LOCKED();

  pcb = (struct raw_pcb *)memp_malloc(MEMP_RAW_PCB);
  /* could allocate RAW PCB? */
  if (pcb != NULL) {
    /* initialize PCB to all zeroes */
    memset(pcb, 0, sizeof(struct raw_pcb));
    pcb->protocol = proto;
    pcb->ttl = RAW_TTL;
#if LWIP_MULTICAST_TX_OPTIONS
    raw_set_multicast_ttl(pcb, RAW_TTL);
#endif /* LWIP_MULTICAST_TX_OPTIONS */
    pcb->next = raw_pcbs;
    raw_pcbs = pcb;
  }
  return pcb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
jmp 0xa2e0
xorl %edi, %edi
callq 0x4930
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa32e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x20f0
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x40(%rax)
movq -0x10(%rbp), %rax
movb $0x40, 0x33(%rax)
movq 0x255d5(%rip), %rcx     # 0x2f8f0
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x255c2(%rip)     # 0x2f8f0
movq -0x10(%rbp), %rax
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/raw.c
// Function: raw_new_ip_type
struct raw_pcb *
raw_new_ip_type(u8_t type, u8_t proto)
{
  struct raw_pcb *pcb;
  LWIP_ASSERT_CORE_LOCKED();
  pcb = raw_new(proto);
#if LWIP_IPV4 && LWIP_IPV6
  if (pcb != NULL) {
    IP_SET_TYPE_VAL(pcb->local_ip,  type);
    IP_SET_TYPE_VAL(pcb->remote_ip, type);
  }
#else /* LWIP_IPV4 && LWIP_IPV6 */
  LWIP_UNUSED_ARG(type);
#endif /* LWIP_IPV4 && LWIP_IPV6 */
  return pcb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %edi
callq 0xa2d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa382
jmp 0xa36a
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
jmp 0xa376
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2c(%rax)
jmp 0xa382
movq -0x10(%rbp), %rax
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/tcp.c
// Function: tcp_fasttmr
void
tcp_fasttmr(void)
{
  struct tcp_pcb *pcb;

  ++tcp_timer_ctr;

tcp_fasttmr_start:
  pcb = tcp_active_pcbs;

  while (pcb != NULL) {
    if (pcb->last_timer != tcp_timer_ctr) {
      struct tcp_pcb *next;
      pcb->last_timer = tcp_timer_ctr;
      /* send delayed ACKs */
      if (pcb->flags & TF_ACK_DELAY) {
        LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACK\n"));
        tcp_ack_now(pcb);
        tcp_output(pcb);
        tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW);
      }
      /* send pending FIN */
      if (pcb->flags & TF_CLOSEPEND) {
        LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: pending FIN\n"));
        tcp_clear_flags(pcb, TF_CLOSEPEND);
        tcp_close_shutdown_fin(pcb);
      }

      next = pcb->next;

      /* If there is data which was previously "refused" by upper layer */
      if (pcb->refused_data != NULL) {
        tcp_active_pcbs_changed = 0;
        tcp_process_refused_data(pcb);
        if (tcp_active_pcbs_changed) {
          /* application callback has changed the pcb list: restart the loop */
          goto tcp_fasttmr_start;
        }
      }
      pcb = next;
    } else {
      pcb = pcb->next;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb 0x25252(%rip), %al      # 0x2f920
addb $0x1, %al
movb %al, 0x2524a(%rip)      # 0x2f920
movq 0x2522b(%rip), %rax     # 0x2f908
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa7eb
movq -0x8(%rbp), %rax
movzbl 0x56(%rax), %eax
movzbl 0x25225(%rip), %ecx     # 0x2f920
cmpl %ecx, %eax
je 0xa7da
movb 0x25217(%rip), %cl      # 0x2f920
movq -0x8(%rbp), %rax
movb %cl, 0x56(%rax)
movq -0x8(%rbp), %rax
movzwl 0x52(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa75f
jmp 0xa722
jmp 0xa724
jmp 0xa726
movq -0x8(%rbp), %rax
movzwl 0x52(%rax), %eax
orl $0x2, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x52(%rax)
movq -0x8(%rbp), %rdi
callq 0x14b70
movq -0x8(%rbp), %rax
movzwl 0x52(%rax), %eax
andl $0xfffc, %eax           # imm = 0xFFFC
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x52(%rax)
jmp 0xa75f
movq -0x8(%rbp), %rax
movzwl 0x52(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xa796
jmp 0xa771
jmp 0xa773
jmp 0xa775
movq -0x8(%rbp), %rax
movzwl 0x52(%rax), %eax
andl $0xfff7, %eax           # imm = 0xFFF7
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x52(%rax)
movq -0x8(%rbp), %rdi
callq 0xd400
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0xa7d0
movb $0x0, 0x25162(%rip)     # 0x2f919
movq -0x8(%rbp), %rdi
callq 0xd530
cmpb $0x0, 0x25152(%rip)     # 0x2f919
je 0xa7ce
jmp 0xa6d6
jmp 0xa7d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa7e6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa6e1
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/tcp.c
// Function: tcp_close
err_t
tcp_close(struct tcp_pcb *pcb)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("tcp_close: invalid pcb", pcb != NULL, return ERR_ARG);
  LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in "));

  tcp_debug_print_state(pcb->state);

  if (pcb->state != LISTEN) {
    /* Set a flag not to receive any more data... */
    tcp_set_flags(pcb, TF_RXCLOSED);
  }
  /* ... and close */
  return tcp_close_shutdown(pcb, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb2e4
jmp 0xb2b5
leaq 0x1c010(%rip), %rdi     # 0x272cc
leaq 0x1cac2(%rip), %rsi     # 0x27d85
movl $0x1e8, %edx            # imm = 0x1E8
leaq 0x1ca9c(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xb2e6
jmp 0xb2e8
jmp 0xb2ea
movq -0x10(%rbp), %rax
movl 0x48(%rax), %edi
callq 0xb340
movq -0x10(%rbp), %rax
cmpl $0x1, 0x48(%rax)
je 0xb31a
jmp 0xb302
movq -0x10(%rbp), %rax
movzwl 0x52(%rax), %eax
orl $0x10, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x52(%rax)
jmp 0xb31a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xb350
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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/tcp.c
// Function: tcp_shutdown
err_t
tcp_shutdown(struct tcp_pcb *pcb, int shut_rx, int shut_tx)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("tcp_shutdown: invalid pcb", pcb != NULL, return ERR_ARG);

  if (pcb->state == LISTEN) {
    return ERR_CONN;
  }
  if (shut_rx) {
    /* shut down the receive side: set a flag not to receive any more data... */
    tcp_set_flags(pcb, TF_RXCLOSED);
    if (shut_tx) {
      /* shutting down the tx AND rx side is the same as closing for the raw API */
      return tcp_close_shutdown(pcb, 1);
    }
    /* ... and free buffered data */
    if (pcb->refused_data != NULL) {
      pbuf_free(pcb->refused_data);
      pcb->refused_data = NULL;
    }
  }
  if (shut_tx) {
    /* This can't happen twice since if it succeeds, the pcb's state is changed.
       Only close in these states as the others directly deallocate the PCB */
    switch (pcb->state) {
      case SYN_RCVD:
      case ESTABLISHED:
      case CLOSE_WAIT:
        return tcp_close_shutdown(pcb, (u8_t)shut_rx);
      default:
        /* Not (yet?) connected, cannot shutdown the TX side as that would bring us
          into CLOSED state, where the PCB is deallocated. */
        return ERR_CONN;
    }
  }
  return ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb68a
jmp 0xb65b
leaq 0x1bc6a(%rip), %rdi     # 0x272cc
leaq 0x1c733(%rip), %rsi     # 0x27d9c
movl $0x207, %edx            # imm = 0x207
leaq 0x1c6f6(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xb68c
movq -0x10(%rbp), %rax
cmpl $0x1, 0x48(%rax)
jne 0xb69f
movb $-0xb, -0x1(%rbp)
jmp 0xb747
cmpl $0x0, -0x14(%rbp)
je 0xb705
jmp 0xb6a7
movq -0x10(%rbp), %rax
movzwl 0x52(%rax), %eax
orl $0x10, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x52(%rax)
cmpl $0x0, -0x18(%rbp)
je 0xb6d6
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xb350
movb %al, -0x1(%rbp)
jmp 0xb747
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0xb703
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x7260
movq -0x10(%rbp), %rax
movq $0x0, 0xc0(%rax)
jmp 0xb705
cmpl $0x0, -0x18(%rbp)
je 0xb743
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x1c(%rbp)
addl $-0x3, %eax
subl $0x2, %eax
jb 0xb729
jmp 0xb71f
movl -0x1c(%rbp), %eax
subl $0x7, %eax
jne 0xb73d
jmp 0xb729
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0xb350
movb %al, -0x1(%rbp)
jmp 0xb747
movb $-0xb, -0x1(%rbp)
jmp 0xb747
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FH0[P]tun_direct/lwip-2.1.2/src/core/tcp.c
// Function: tcp_segs_free
void
tcp_segs_free(struct tcp_seg *seg)
{
  while (seg != NULL) {
    struct tcp_seg *next = seg->next;
    tcp_seg_free(seg);
    seg = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbc81
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd7a0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbc5c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)