// File: /workspace/github_c_makefile_star2_O3/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 0x16092(%rip)           # 0x1c91c
incb 0x16090(%rip)           # 0x1c920
movq 0x16071(%rip), %rbx     # 0x1c908
testq %rbx, %rbx
je 0x6cb3
movabsq $0x83126e978d4fe0, %r12 # imm = 0x83126E978D4FE0
xorl %ebp, %ebp
movl 0x48(%rbx), %eax
cmpl $0xa, %eax
je 0x6d3f
cmpl $0x1, %eax
je 0x6d5e
testl %eax, %eax
je 0x6d7d
movb 0x16051(%rip), %cl      # 0x1c920
cmpb %cl, 0x56(%rbx)
jne 0x68e0
movq 0x38(%rbx), %r15
movq %rbx, %rbp
jmp 0x6c46
movb %cl, 0x56(%rbx)
movb 0x7a(%rbx), %cl
movb $0x1, %r14b
cmpl $0x2, %eax
jne 0x68f8
cmpb $0x5, %cl
jbe 0x6901
jmp 0x6a91
cmpb $0xb, %cl
ja 0x6a91
movzbl 0xfd(%rbx), %eax
testq %rax, %rax
je 0x699b
cmpq $0x0, 0xb0(%rbx)
jne 0x6e12
cmpq $0x0, 0xa8(%rbx)
je 0x6e2e
movb $0x1, %r14b
cmpb $0xb, 0xfe(%rbx)
ja 0x6a91
decl %eax
leaq 0xea76(%rip), %rcx      # 0x153bc
movb (%rax,%rcx), %al
movb 0xfc(%rbx), %cl
cmpb %al, %cl
jae 0x695b
incb %cl
movb %cl, 0xfc(%rbx)
cmpb %al, %cl
jb 0x6a8e
movzwl 0x98(%rbx), %eax
testw %ax, %ax
je 0x6a69
movzwl %ax, %esi
movq %rbx, %rdi
callq 0xb79a
testb %al, %al
jne 0x6a75
movq %rbx, %rdi
callq 0xbd02
testb %al, %al
jne 0x6a75
jmp 0x6a8e
movzwl 0x68(%rbx), %eax
cmpl $0x7ffe, %eax           # imm = 0x7FFE
ja 0x69ac
incl %eax
movw %ax, 0x68(%rbx)
cmpw 0x78(%rbx), %ax
jl 0x6a8e
movq %rbx, %rdi
callq 0xc407
testb %al, %al
je 0x69de
cmpq $0x0, 0xb0(%rbx)
jne 0x6a8e
cmpq $0x0, 0xa8(%rbx)
je 0x6a8e
cmpl $0x2, 0x48(%rbx)
je 0x6a1c
movzbl 0x7a(%rbx), %eax
cmpb $0xc, %al
movl $0xc, %ecx
cmovael %ecx, %eax
movzbl %al, %eax
movswl 0x74(%rbx), %ecx
sarl $0x3, %ecx
movswl 0x76(%rbx), %edx
addl %ecx, %edx
leaq 0xe9ba(%rip), %rcx      # 0x153c3
movb (%rax,%rcx), %cl
shll %cl, %edx
movl $0x7fff, %eax           # imm = 0x7FFF
cmpl %eax, %edx
cmovgel %eax, %edx
movw %dx, 0x78(%rbx)
xorl %r14d, %r14d
movw %r14w, 0x68(%rbx)
movl 0x80(%rbx), %eax
movl 0x98(%rbx), %ecx
cmpw %cx, %ax
cmovbl %eax, %ecx
movzwl %cx, %eax
shrl %eax
movzwl 0x6a(%rbx), %ecx
movl %ecx, %edx
addl %ecx, %edx
cmpw %dx, %ax
cmoval %eax, %edx
movw %dx, 0x82(%rbx)
movw %cx, 0x80(%rbx)
movw %r14w, 0xa2(%rbx)
movq %rbx, %rdi
callq 0xc538
jmp 0x6a91
movq %rbx, %rdi
callq 0xca6d
testb %al, %al
jne 0x6a8e
movb $0x0, 0xfc(%rbx)
movb 0xfd(%rbx), %al
cmpb $0x6, %al
ja 0x6a8e
incb %al
movb %al, 0xfd(%rbx)
xorl %r14d, %r14d
movl 0x48(%rbx), %eax
cmpl $0x6, %eax
jne 0x6aaf
testb $0x10, 0x52(%rbx)
je 0x6aaf
movl 0x15e77(%rip), %ecx     # 0x1c91c
subl 0x58(%rbx), %ecx
cmpl $0x29, %ecx
sbbb $-0x1, %r14b
movb $0x1, %r13b
testb $0x8, 0x31(%rbx)
je 0x6b11
cmpl $0x7, %eax
je 0x6ac2
cmpl $0x4, %eax
jne 0x6b11
movl 0x15e54(%rip), %ecx     # 0x1c91c
subl 0x58(%rbx), %ecx
movl 0xf8(%rbx), %esi
leaq 0xa4cb8(%rsi), %rax
mulq %r12
cmpl %ecx, %edx
jae 0x6ae7
incb %r14b
xorl %r13d, %r13d
jmp 0x6b11
movzbl 0xff(%rbx), %eax
imulq $0x124f8, %rax, %rax    # imm = 0x124F8
addq %rsi, %rax
mulq %r12
cmpl %ecx, %edx
jae 0x6b11
movq %rbx, %rdi
callq 0xca02
testb %al, %al
jne 0x6b11
incb 0xff(%rbx)
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x6b4e
movl 0x15df9(%rip), %eax     # 0x1c91c
subl 0x58(%rbx), %eax
movswl 0x78(%rbx), %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,2), %ecx
cmpl %ecx, %eax
jb 0x6b4e
movq (%rdi), %r15
callq 0x817c
movq %r15, %rdi
testq %r15, %r15
jne 0x6b33
movq $0x0, 0xb8(%rbx)
movl 0x48(%rbx), %eax
cmpl $0x3, %eax
je 0x6b62
cmpl $0x9, %eax
jne 0x6b76
movl $0xf0, %eax
jmp 0x6b67
movl $0x28, %eax
movl 0x15daf(%rip), %ecx     # 0x1c91c
subl 0x58(%rbx), %ecx
cmpl %ecx, %eax
adcb $0x0, %r14b
testb %r14b, %r14b
je 0x6ba9
movq 0xf0(%rbx), %r12
movq %rbx, %rdi
callq 0x7eb3
movq 0x15d77(%rip), %rax     # 0x1c908
testq %rbp, %rbp
je 0x6bc3
cmpq %rax, %rbx
je 0x6dda
movq 0x38(%rbx), %r15
movq %r15, 0x38(%rbp)
jmp 0x6bd7
movq 0x38(%rbx), %r15
movb 0x54(%rbx), %al
incb %al
movb %al, 0x54(%rbx)
cmpb 0x55(%rbx), %al
jae 0x6c54
movq %rbx, %rbp
jmp 0x6c3c
cmpq %rbx, %rax
jne 0x6e4a
movq 0x38(%rbx), %r15
movq %r15, 0x15d31(%rip)     # 0x1c908
testb %r13b, %r13b
jne 0x6c04
movl 0x5c(%rbx), %edx
movl 0x88(%rbx), %esi
leaq 0x18(%rbx), %r8
movzwl 0x4e(%rbx), %r9d
movzwl 0x50(%rbx), %eax
movl %eax, (%rsp)
movq %rbx, %rdi
movq %rbx, %rcx
callq 0xc757
movq 0x38(%rbx), %r15
movq 0x40(%rbx), %r14
movq %rbx, %rdi
callq 0x6780
movb $0x0, 0x15d02(%rip)     # 0x1c919
testq %r12, %r12
je 0x6c3c
movq %r14, %rdi
movl $0xfffffff3, %esi       # imm = 0xFFFFFFF3
callq *%r12
cmpb $0x0, 0x15ceb(%rip)     # 0x1c919
movabsq $0x83126e978d4fe0, %r12 # imm = 0x83126E978D4FE0
jne 0x6c87
jmp 0x6c46
movabsq $0x83126e978d4fe0, %r12 # imm = 0x83126E978D4FE0
movq %r15, %rbx
testq %r15, %r15
jne 0x68ac
jmp 0x6cb3
xorl %eax, %eax
movb %al, 0x54(%rbx)
movb %al, 0x15cba(%rip)      # 0x1c919
movq 0xe8(%rbx), %rax
testq %rax, %rax
movabsq $0x83126e978d4fe0, %r12 # imm = 0x83126E978D4FE0
je 0x6ca6
movq 0x40(%rbx), %rdi
movq %rbx, %rsi
callq *%rax
cmpb $0x0, 0x15c94(%rip)     # 0x1c919
je 0x6c9e
movq 0x15c7a(%rip), %rbx     # 0x1c908
movl $0x0, %ebp
testq %rbx, %rbx
jne 0x68ac
jmp 0x6cb3
testb %al, %al
jne 0x68d8
movq %rbx, %rdi
callq 0xbd02
jmp 0x68d8
movq 0x15c56(%rip), %rbx     # 0x1c910
testq %rbx, %rbx
je 0x6d30
xorl %r14d, %r14d
cmpl $0xa, 0x48(%rbx)
jne 0x6d9c
movl 0x15c4a(%rip), %eax     # 0x1c91c
subl 0x58(%rbx), %eax
cmpl $0xf1, %eax
jae 0x6ce5
movq %rbx, %r14
movq 0x38(%rbx), %rbx
jmp 0x6d2b
movq %rbx, %rdi
callq 0x7eb3
movq 0x15c1c(%rip), %rax     # 0x1c910
testq %r14, %r14
je 0x6d0c
cmpq %rax, %rbx
je 0x6dbb
movq 0x38(%rbx), %r15
movq %r15, 0x38(%r14)
jmp 0x6d20
cmpq %rbx, %rax
jne 0x6df6
movq 0x38(%rbx), %r15
movq %r15, 0x15bf0(%rip)     # 0x1c910
movq %rbx, %rdi
callq 0x6780
movq %r15, %rbx
testq %rbx, %rbx
jne 0x6cc2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd586(%rip), %rdi      # 0x142cc
leaq 0xe1a7(%rip), %rsi      # 0x14ef4
leaq 0xdf34(%rip), %rcx      # 0x14c88
movl $0x4c0, %edx            # imm = 0x4C0
jmp 0x6e64
leaq 0xd567(%rip), %rdi      # 0x142cc
leaq 0xe15e(%rip), %rsi      # 0x14eca
leaq 0xdf15(%rip), %rcx      # 0x14c88
movl $0x4bf, %edx            # imm = 0x4BF
jmp 0x6e64
leaq 0xd548(%rip), %rdi      # 0x142cc
leaq 0xe115(%rip), %rsi      # 0x14ea0
leaq 0xdef6(%rip), %rcx      # 0x14c88
movl $0x4be, %edx            # imm = 0x4BE
jmp 0x6e64
leaq 0xd529(%rip), %rdi      # 0x142cc
leaq 0xe233(%rip), %rsi      # 0x14fdd
leaq 0xded7(%rip), %rcx      # 0x14c88
movl $0x5a1, %edx            # imm = 0x5A1
jmp 0x6e64
leaq 0xd50a(%rip), %rdi      # 0x142cc
leaq 0xe243(%rip), %rsi      # 0x1500c
leaq 0xdeb8(%rip), %rcx      # 0x14c88
movl $0x5af, %edx            # imm = 0x5AF
jmp 0x6e64
leaq 0xd4eb(%rip), %rdi      # 0x142cc
leaq 0xe1a0(%rip), %rsi      # 0x14f88
leaq 0xde99(%rip), %rcx      # 0x14c88
movl $0x56d, %edx            # imm = 0x56D
jmp 0x6e64
leaq 0xd4cf(%rip), %rdi      # 0x142cc
leaq 0xe22f(%rip), %rsi      # 0x15033
leaq 0xde7d(%rip), %rcx      # 0x14c88
movl $0x5b3, %edx            # imm = 0x5B3
jmp 0x6e64
leaq 0xd4b3(%rip), %rdi      # 0x142cc
leaq 0xe101(%rip), %rsi      # 0x14f21
leaq 0xde61(%rip), %rcx      # 0x14c88
movl $0x4d4, %edx            # imm = 0x4D4
jmp 0x6e64
leaq 0xd497(%rip), %rdi      # 0x142cc
leaq 0xe117(%rip), %rsi      # 0x14f53
leaq 0xde45(%rip), %rcx      # 0x14c88
movl $0x4d5, %edx            # imm = 0x4D5
jmp 0x6e64
leaq 0xd47b(%rip), %rdi      # 0x142cc
leaq 0xe15b(%rip), %rsi      # 0x14fb3
leaq 0xde29(%rip), %rcx      # 0x14c88
movl $0x571, %edx            # imm = 0x571
xorl %eax, %eax
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
callq 0x2050