// File: /workspace/github_c_makefile_star2_O2/FH0[P]tun_direct/lwip-2.1.2/src/core/tcp.c
// Function: tcp_slowtmr
void
tcp_slowtmr(void)
{
  struct tcp_pcb *pcb, *prev;
  tcpwnd_size_t eff_wnd;
  u8_t pcb_remove;      /* flag if a PCB should be removed */
  u8_t pcb_reset;       /* flag if a RST should be sent when removing */
  err_t err;

  err = ERR_OK;

  ++tcp_ticks;
  ++tcp_timer_ctr;

tcp_slowtmr_start:
  /* Steps through all of the active PCBs. */
  prev = NULL;
  pcb = tcp_active_pcbs;
  if (pcb == NULL) {
    LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbs\n"));
  }
  while (pcb != NULL) {
    LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcb\n"));
    LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED);
    LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN);
    LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT);
    if (pcb->last_timer == tcp_timer_ctr) {
      /* skip this pcb, we have already processed it */
      prev = pcb;
      pcb = pcb->next;
      continue;
    }
    pcb->last_timer = tcp_timer_ctr;

    pcb_remove = 0;
    pcb_reset = 0;

    if (pcb->state == SYN_SENT && pcb->nrtx >= TCP_SYNMAXRTX) {
      ++pcb_remove;
      LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reached\n"));
    } else if (pcb->nrtx >= TCP_MAXRTX) {
      ++pcb_remove;
      LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reached\n"));
    } else {
      if (pcb->persist_backoff > 0) {
        LWIP_ASSERT("tcp_slowtimr: persist ticking with in-flight data", pcb->unacked == NULL);
        LWIP_ASSERT("tcp_slowtimr: persist ticking with empty send buffer", pcb->unsent != NULL);
        if (pcb->persist_probe >= TCP_MAXRTX) {
          ++pcb_remove; /* max probes reached */
        } else {
          u8_t backoff_cnt = tcp_persist_backoff[pcb->persist_backoff - 1];
          if (pcb->persist_cnt < backoff_cnt) {
            pcb->persist_cnt++;
          }
          if (pcb->persist_cnt >= backoff_cnt) {
            int next_slot = 1; /* increment timer to next slot */
            /* If snd_wnd is zero, send 1 byte probes */
            if (pcb->snd_wnd == 0) {
              if (tcp_zero_window_probe(pcb) != ERR_OK) {
                next_slot = 0; /* try probe again with current slot */
              }
              /* snd_wnd not fully closed, split unsent head and fill window */
            } else {
              if (tcp_split_unsent_seg(pcb, (u16_t)pcb->snd_wnd) == ERR_OK) {
                if (tcp_output(pcb) == ERR_OK) {
                  /* sending will cancel persist timer, else retry with current slot */
                  next_slot = 0;
                }
              }
            }
            if (next_slot) {
              pcb->persist_cnt = 0;
              if (pcb->persist_backoff < sizeof(tcp_persist_backoff)) {
                pcb->persist_backoff++;
              }
            }
          }
        }
      } else {
        /* Increase the retransmission timer if it is running */
        if ((pcb->rtime >= 0) && (pcb->rtime < 0x7FFF)) {
          ++pcb->rtime;
        }

        if (pcb->rtime >= pcb->rto) {
          /* Time for a retransmission. */
          LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %"S16_F
                                      " pcb->rto %"S16_F"\n",
                                      pcb->rtime, pcb->rto));
          /* If prepare phase fails but we have unsent data but no unacked data,
             still execute the backoff calculations below, as this means we somehow
             failed to send segment. */
          if ((tcp_rexmit_rto_prepare(pcb) == ERR_OK) || ((pcb->unacked == NULL) && (pcb->unsent != NULL))) {
            /* Double retransmission time-out unless we are trying to
             * connect to somebody (i.e., we are in SYN_SENT). */
            if (pcb->state != SYN_SENT) {
              u8_t backoff_idx = LWIP_MIN(pcb->nrtx, sizeof(tcp_backoff) - 1);
              int calc_rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[backoff_idx];
              pcb->rto = (s16_t)LWIP_MIN(calc_rto, 0x7FFF);
            }

            /* Reset the retransmission timer. */
            pcb->rtime = 0;

            /* Reduce congestion window and ssthresh. */
            eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
            pcb->ssthresh = eff_wnd >> 1;
            if (pcb->ssthresh < (tcpwnd_size_t)(pcb->mss << 1)) {
              pcb->ssthresh = (tcpwnd_size_t)(pcb->mss << 1);
            }
            pcb->cwnd = pcb->mss;
            LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %"TCPWNDSIZE_F
                                         " ssthresh %"TCPWNDSIZE_F"\n",
                                         pcb->cwnd, pcb->ssthresh));
            pcb->bytes_acked = 0;

            /* The following needs to be called AFTER cwnd is set to one
               mss - STJ */
            tcp_rexmit_rto_commit(pcb);
          }
        }
      }
    }
    /* Check if this PCB has stayed too long in FIN-WAIT-2 */
    if (pcb->state == FIN_WAIT_2) {
      /* If this PCB is in FIN_WAIT_2 because of SHUT_WR don't let it time out. */
      if (pcb->flags & TF_RXCLOSED) {
        /* PCB was fully closed (either through close() or SHUT_RDWR):
           normal FIN-WAIT timeout handling. */
        if ((u32_t)(tcp_ticks - pcb->tmr) >
            TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
          ++pcb_remove;
          LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2\n"));
        }
      }
    }

    /* Check if KEEPALIVE should be sent */
    if (ip_get_option(pcb, SOF_KEEPALIVE) &&
        ((pcb->state == ESTABLISHED) ||
         (pcb->state == CLOSE_WAIT))) {
      if ((u32_t)(tcp_ticks - pcb->tmr) >
          (pcb->keep_idle + TCP_KEEP_DUR(pcb)) / TCP_SLOW_INTERVAL) {
        LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to "));
        ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip);
        LWIP_DEBUGF(TCP_DEBUG, ("\n"));

        ++pcb_remove;
        ++pcb_reset;
      } else if ((u32_t)(tcp_ticks - pcb->tmr) >
                 (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEP_INTVL(pcb))
                 / TCP_SLOW_INTERVAL) {
        err = tcp_keepalive(pcb);
        if (err == ERR_OK) {
          pcb->keep_cnt_sent++;
        }
      }
    }

    /* If this PCB has queued out of sequence data, but has been
       inactive for too long, will drop the data (it will eventually
       be retransmitted). */
#if TCP_QUEUE_OOSEQ
    if (pcb->ooseq != NULL &&
        (tcp_ticks - pcb->tmr >= (u32_t)pcb->rto * TCP_OOSEQ_TIMEOUT)) {
      LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued data\n"));
      tcp_free_ooseq(pcb);
    }
#endif /* TCP_QUEUE_OOSEQ */

    /* Check if this PCB has stayed too long in SYN-RCVD */
    if (pcb->state == SYN_RCVD) {
      if ((u32_t)(tcp_ticks - pcb->tmr) >
          TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
        ++pcb_remove;
        LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVD\n"));
      }
    }

    /* Check if this PCB has stayed too long in LAST-ACK */
    if (pcb->state == LAST_ACK) {
      if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
        ++pcb_remove;
        LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in LAST-ACK\n"));
      }
    }

    /* If the PCB should be removed, do it. */
    if (pcb_remove) {
      struct tcp_pcb *pcb2;
#if LWIP_CALLBACK_API
      tcp_err_fn err_fn = pcb->errf;
#endif /* LWIP_CALLBACK_API */
      void *err_arg;
      enum tcp_state last_state;
      tcp_pcb_purge(pcb);
      /* Remove PCB from tcp_active_pcbs list. */
      if (prev != NULL) {
        LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
        prev->next = pcb->next;
      } else {
        /* This PCB was the first. */
        LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
        tcp_active_pcbs = pcb->next;
      }

      if (pcb_reset) {
        tcp_rst(pcb, pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
                pcb->local_port, pcb->remote_port);
      }

      err_arg = pcb->callback_arg;
      last_state = pcb->state;
      pcb2 = pcb;
      pcb = pcb->next;
      tcp_free(pcb2);

      tcp_active_pcbs_changed = 0;
      TCP_EVENT_ERR(last_state, err_fn, err_arg, ERR_ABRT);
      if (tcp_active_pcbs_changed) {
        goto tcp_slowtmr_start;
      }
    } else {
      /* get the 'next' element now and work with 'prev' below (in case of abort) */
      prev = pcb;
      pcb = pcb->next;

      /* We check if we should poll the connection. */
      ++prev->polltmr;
      if (prev->polltmr >= prev->pollinterval) {
        prev->polltmr = 0;
        LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n"));
        tcp_active_pcbs_changed = 0;
        TCP_EVENT_POLL(prev, err);
        if (tcp_active_pcbs_changed) {
          goto tcp_slowtmr_start;
        }
        /* if err == ERR_ABRT, 'prev' is already deallocated */
        if (err == ERR_OK) {
          tcp_output(prev);
        }
      }
    }
  }


  /* Steps through all of the TIME-WAIT PCBs. */
  prev = NULL;
  pcb = tcp_tw_pcbs;
  while (pcb != NULL) {
    LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
    pcb_remove = 0;

    /* Check if this PCB has stayed long enough in TIME-WAIT */
    if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
      ++pcb_remove;
    }

    /* If the PCB should be removed, do it. */
    if (pcb_remove) {
      struct tcp_pcb *pcb2;
      tcp_pcb_purge(pcb);
      /* Remove PCB from tcp_tw_pcbs list. */
      if (prev != NULL) {
        LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
        prev->next = pcb->next;
      } else {
        /* This PCB was the first. */
        LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
        tcp_tw_pcbs = pcb->next;
      }
      pcb2 = pcb;
      pcb = pcb->next;
      tcp_free(pcb2);
    } else {
      prev = pcb;
      pcb = pcb->next;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x172e1(%rip)           # 0x1d91c
incb 0x172df(%rip)           # 0x1d920
pushq $-0xd
popq %rbx
movq 0x172bd(%rip), %r14     # 0x1d908
xorl %ebp, %ebp
movq %r14, %r15
testq %r15, %r15
je 0x6a57
movl 0x48(%r15), %eax
cmpl $0xa, %eax
je 0x6ae3
cmpl $0x1, %eax
je 0x6b21
testl %eax, %eax
je 0x6b02
movb 0x172a3(%rip), %cl      # 0x1d920
cmpb %cl, 0x56(%r15)
je 0x69e7
movb %cl, 0x56(%r15)
movb 0x7a(%r15), %cl
movb $0x1, %r14b
cmpl $0x2, %eax
jne 0x669c
cmpb $0x5, %cl
jmp 0x669f
cmpb $0xb, %cl
movl $0x1f4, %r13d           # imm = 0x1F4
ja 0x684c
movzbl 0xfd(%r15), %eax
testq %rax, %rax
je 0x674a
cmpq $0x0, 0xb0(%r15)
jne 0x6bd2
cmpq $0x0, 0xa8(%r15)
je 0x6bee
movb $0x1, %r14b
cmpb $0xb, 0xfe(%r15)
ja 0x684c
decl %eax
leaq 0xece2(%rip), %rcx      # 0x153d4
movb (%rax,%rcx), %al
movb 0xfc(%r15), %cl
cmpb %al, %cl
jae 0x6709
incb %cl
movb %cl, 0xfc(%r15)
cmpb %al, %cl
jb 0x6849
movzwl 0x98(%r15), %eax
testw %ax, %ax
je 0x6821
movzwl %ax, %esi
movq %r15, %rdi
callq 0xb2ae
testb %al, %al
jne 0x682d
movq %r15, %rdi
callq 0xb804
testb %al, %al
jne 0x682d
jmp 0x6849
movzwl 0x68(%r15), %eax
cmpw $0x7ffe, %ax            # imm = 0x7FFE
ja 0x675c
incl %eax
movw %ax, 0x68(%r15)
cmpw 0x78(%r15), %ax
jl 0x6849
movq %r15, %rdi
callq 0xbedd
testb %al, %al
je 0x678f
cmpq $0x0, 0xb0(%r15)
jne 0x6849
cmpq $0x0, 0xa8(%r15)
je 0x6849
cmpl $0x2, 0x48(%r15)
je 0x67d0
movzbl 0x7a(%r15), %eax
cmpb $0xc, %al
pushq $0xc
popq %rcx
cmovael %ecx, %eax
movzbl %al, %eax
movswl 0x74(%r15), %ecx
sarl $0x3, %ecx
movswl 0x76(%r15), %edx
addl %ecx, %edx
leaq 0xec1f(%rip), %rcx      # 0x153db
movb (%rax,%rcx), %cl
shll %cl, %edx
movl $0x7fff, %eax           # imm = 0x7FFF
cmpl %eax, %edx
cmovgel %eax, %edx
movw %dx, 0x78(%r15)
andw $0x0, 0x68(%r15)
movl 0x80(%r15), %eax
movl 0x98(%r15), %ecx
cmpw %cx, %ax
cmovbl %eax, %ecx
movzwl %cx, %eax
shrl %eax
movzwl 0x6a(%r15), %ecx
movl %ecx, %edx
addl %ecx, %edx
cmpw %dx, %ax
cmoval %eax, %edx
movw %dx, 0x82(%r15)
movw %cx, 0x80(%r15)
andw $0x0, 0xa2(%r15)
movq %r15, %rdi
callq 0xc008
jmp 0x6849
movq %r15, %rdi
callq 0xc506
testb %al, %al
jne 0x6849
movb $0x0, 0xfc(%r15)
movb 0xfd(%r15), %al
cmpb $0x6, %al
ja 0x6849
incb %al
movb %al, 0xfd(%r15)
xorl %r14d, %r14d
movl 0x48(%r15), %eax
cmpl $0x6, %eax
jne 0x686d
testb $0x10, 0x52(%r15)
je 0x686d
movl 0x170ba(%rip), %ecx     # 0x1d91c
subl 0x58(%r15), %ecx
cmpl $0x29, %ecx
sbbb $-0x1, %r14b
movb $0x1, %r12b
testb $0x8, 0x31(%r15)
je 0x68d8
cmpl $0x7, %eax
je 0x6881
cmpl $0x4, %eax
jne 0x68d8
movl 0x17095(%rip), %ecx     # 0x1d91c
subl 0x58(%r15), %ecx
movl 0xf8(%r15), %esi
leaq 0xa4cb8(%rsi), %rax
xorl %edx, %edx
divq %r13
cmpl %ecx, %eax
jae 0x68aa
incb %r14b
xorl %r12d, %r12d
jmp 0x68d8
movzbl 0xff(%r15), %eax
imulq $0x124f8, %rax, %rax    # imm = 0x124F8
addq %rsi, %rax
xorl %edx, %edx
divq %r13
cmpl %ecx, %eax
jae 0x68d8
movq %r15, %rdi
callq 0xc49b
testb %al, %al
jne 0x68d8
incb 0xff(%r15)
cmpq $0x0, 0xb8(%r15)
je 0x6900
movl 0x17034(%rip), %eax     # 0x1d91c
subl 0x58(%r15), %eax
movswl 0x78(%r15), %ecx
imull $0x6, %ecx, %ecx
cmpl %ecx, %eax
jb 0x6900
movq %r15, %rdi
callq 0x7ba1
movl 0x48(%r15), %eax
cmpl $0x9, %eax
je 0x691f
cmpl $0x3, %eax
jne 0x6930
movl 0x17008(%rip), %eax     # 0x1d91c
subl 0x58(%r15), %eax
cmpl $0x28, %eax
jbe 0x6930
jmp 0x6939
movl 0x16ff7(%rip), %eax     # 0x1d91c
subl 0x58(%r15), %eax
cmpl $0xf0, %eax
ja 0x6939
testb %r14b, %r14b
je 0x69f3
movq 0xf0(%r15), %r13
movq %r15, %rdi
callq 0x7bc0
movq 0x16fb9(%rip), %rax     # 0x1d908
testq %rbp, %rbp
je 0x6967
cmpq %rax, %r15
je 0x6b7e
movq 0x38(%r15), %r14
movq %r14, 0x38(%rbp)
jmp 0x697b
cmpq %r15, %rax
jne 0x6bb6
movq 0x38(%r15), %r14
movq %r14, 0x16f8d(%rip)     # 0x1d908
testb %r12b, %r12b
jne 0x69ab
movl 0x5c(%r15), %edx
movl 0x88(%r15), %esi
leaq 0x18(%r15), %r8
movzwl 0x4e(%r15), %r9d
movzwl 0x50(%r15), %eax
movl %eax, (%rsp)
movq %r15, %rdi
movq %r15, %rcx
callq 0xc200
movq 0x38(%r15), %r14
movq 0x40(%r15), %r12
movq %r15, %rdi
callq 0x6530
movb $0x0, 0x16f5b(%rip)     # 0x1d919
movq %r14, %r15
testq %r13, %r13
je 0x6650
movq %r12, %rdi
movl %ebx, %esi
callq *%r13
cmpb $0x0, 0x16f40(%rip)     # 0x1d919
movq %r14, %r15
je 0x6650
jmp 0x6644
movq 0x38(%r15), %r14
movq %r15, %rbp
jmp 0x664d
movq 0x38(%r15), %r14
movb 0x54(%r15), %al
incb %al
movb %al, 0x54(%r15)
movq %r15, %rbp
cmpb 0x55(%r15), %al
jb 0x664d
xorl %eax, %eax
movb %al, 0x54(%r15)
movb %al, 0x16eff(%rip)      # 0x1d919
movq 0xe8(%r15), %rax
testq %rax, %rax
je 0x6a47
movq 0x40(%r15), %rdi
movq %r15, %rsi
callq *%rax
cmpb $0x0, 0x16ee3(%rip)     # 0x1d919
jne 0x6644
movq %r15, %rbp
testb %al, %al
jne 0x664d
movq %r15, %rdi
callq 0xb804
movq %r15, %rbp
jmp 0x664d
leaq 0x16eb2(%rip), %rax     # 0x1d910
xorl %r14d, %r14d
movq (%rax), %rbx
testq %rbx, %rbx
je 0x6ad4
cmpl $0xa, 0x48(%rbx)
jne 0x6b40
movl 0x16ea3(%rip), %eax     # 0x1d91c
subl 0x58(%rbx), %eax
cmpl $0xf1, %eax
jb 0x6acb
movq %rbx, %rdi
callq 0x7bc0
movq 0x16e7e(%rip), %rax     # 0x1d910
testq %r14, %r14
je 0x6aaa
cmpq %rax, %rbx
je 0x6b5f
movq 0x38(%rbx), %r15
movq %r15, 0x38(%r14)
jmp 0x6abe
cmpq %rbx, %rax
jne 0x6b9a
movq 0x38(%rbx), %r15
movq %r15, 0x16e52(%rip)     # 0x1d910
movq %rbx, %rdi
callq 0x6530
movq %r15, %rbx
jmp 0x6a64
leaq 0x38(%rbx), %rax
movq %rbx, %r14
jmp 0x6a61
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd7e2(%rip), %rdi      # 0x142cc
leaq 0xe41a(%rip), %rsi      # 0x14f0b
leaq 0xe1a7(%rip), %rcx      # 0x14c9f
movl $0x4c0, %edx            # imm = 0x4C0
jmp 0x6c08
leaq 0xd7c3(%rip), %rdi      # 0x142cc
leaq 0xe3a7(%rip), %rsi      # 0x14eb7
leaq 0xe188(%rip), %rcx      # 0x14c9f
movl $0x4be, %edx            # imm = 0x4BE
jmp 0x6c08
leaq 0xd7a4(%rip), %rdi      # 0x142cc
leaq 0xe3b2(%rip), %rsi      # 0x14ee1
leaq 0xe169(%rip), %rcx      # 0x14c9f
movl $0x4bf, %edx            # imm = 0x4BF
jmp 0x6c08
leaq 0xd785(%rip), %rdi      # 0x142cc
leaq 0xe4a6(%rip), %rsi      # 0x14ff4
leaq 0xe14a(%rip), %rcx      # 0x14c9f
movl $0x5a1, %edx            # imm = 0x5A1
jmp 0x6c08
leaq 0xd766(%rip), %rdi      # 0x142cc
leaq 0xe4b6(%rip), %rsi      # 0x15023
leaq 0xe12b(%rip), %rcx      # 0x14c9f
movl $0x5af, %edx            # imm = 0x5AF
jmp 0x6c08
leaq 0xd747(%rip), %rdi      # 0x142cc
leaq 0xe413(%rip), %rsi      # 0x14f9f
leaq 0xe10c(%rip), %rcx      # 0x14c9f
movl $0x56d, %edx            # imm = 0x56D
jmp 0x6c08
leaq 0xd72b(%rip), %rdi      # 0x142cc
leaq 0xe4a2(%rip), %rsi      # 0x1504a
leaq 0xe0f0(%rip), %rcx      # 0x14c9f
movl $0x5b3, %edx            # imm = 0x5B3
jmp 0x6c08
leaq 0xd70f(%rip), %rdi      # 0x142cc
leaq 0xe406(%rip), %rsi      # 0x14fca
leaq 0xe0d4(%rip), %rcx      # 0x14c9f
movl $0x571, %edx            # imm = 0x571
jmp 0x6c08
leaq 0xd6f3(%rip), %rdi      # 0x142cc
leaq 0xe358(%rip), %rsi      # 0x14f38
leaq 0xe0b8(%rip), %rcx      # 0x14c9f
movl $0x4d4, %edx            # imm = 0x4D4
jmp 0x6c08
leaq 0xd6d7(%rip), %rdi      # 0x142cc
leaq 0xe36e(%rip), %rsi      # 0x14f6a
leaq 0xe09c(%rip), %rcx      # 0x14c9f
movl $0x4d5, %edx            # imm = 0x4D5
xorl %eax, %eax
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
callq 0x2050