// File: /workspace/github_c_makefile_star2_O1/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 0x16fa0(%rip)           # 0x1d91c
incb 0x16f9e(%rip)           # 0x1d920
movq 0x16f7f(%rip), %rbx     # 0x1d908
testq %rbx, %rbx
je 0x6d9b
movabsq $0x83126e978d4fe0, %r12 # imm = 0x83126E978D4FE0
xorl %ebp, %ebp
movl 0x48(%rbx), %eax
cmpl $0xa, %eax
je 0x6e2b
cmpl $0x1, %eax
je 0x6e4a
testl %eax, %eax
je 0x6e69
movb 0x16f5f(%rip), %cl      # 0x1d920
cmpb %cl, 0x56(%rbx)
jne 0x69da
movq 0x38(%rbx), %r13
movq %rbx, %rbp
movq %r13, %rbx
testq %r13, %r13
jne 0x699e
jmp 0x6d9b
movb %cl, 0x56(%rbx)
cmpl $0x2, %eax
jne 0x69ef
movb $0x1, %r14b
cmpb $0x5, 0x7a(%rbx)
ja 0x6b93
movb $0x1, %r14b
cmpb $0xb, 0x7a(%rbx)
ja 0x6b93
movzbl 0xfd(%rbx), %eax
testq %rax, %rax
je 0x6a94
cmpq $0x0, 0xb0(%rbx)
jne 0x6efe
cmpq $0x0, 0xa8(%rbx)
je 0x6f1a
cmpb $0xb, 0xfe(%rbx)
ja 0x6b93
decl %eax
leaq 0xf996(%rip), %rcx      # 0x163d4
movb (%rax,%rcx), %al
movb 0xfc(%rbx), %cl
cmpb %al, %cl
jae 0x6a53
incb %cl
movb %cl, 0xfc(%rbx)
cmpb %al, 0xfc(%rbx)
jb 0x6b90
movzwl 0x98(%rbx), %eax
testw %ax, %ax
je 0x6b66
movzwl %ax, %esi
movq %rbx, %rdi
callq 0xba3d
testb %al, %al
jne 0x6b77
movq %rbx, %rdi
callq 0xbfab
testb %al, %al
sete %al
jmp 0x6b73
movzwl 0x68(%rbx), %eax
cmpl $0x7ffe, %eax           # imm = 0x7FFE
ja 0x6aa5
incl %eax
movw %ax, 0x68(%rbx)
movzwl 0x68(%rbx), %eax
cmpw 0x78(%rbx), %ax
jl 0x6b90
movq %rbx, %rdi
callq 0xc694
testb %al, %al
je 0x6adb
cmpq $0x0, 0xb0(%rbx)
jne 0x6b90
cmpq $0x0, 0xa8(%rbx)
je 0x6b90
cmpl $0x2, 0x48(%rbx)
je 0x6b19
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 0xf8d5(%rip), %rcx      # 0x163db
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 0xc7c5
jmp 0x6b93
movq %rbx, %rdi
callq 0xccec
testb %al, %al
setne %al
testb %al, %al
jne 0x6b90
movb $0x0, 0xfc(%rbx)
movb 0xfd(%rbx), %al
cmpb $0x6, %al
ja 0x6b90
incb %al
movb %al, 0xfd(%rbx)
xorl %r14d, %r14d
movl 0x48(%rbx), %eax
cmpl $0x6, %eax
jne 0x6bb1
testb $0x10, 0x52(%rbx)
je 0x6bb1
movl 0x16d75(%rip), %ecx     # 0x1d91c
subl 0x58(%rbx), %ecx
cmpl $0x29, %ecx
sbbb $-0x1, %r14b
movb $0x1, %r13b
testb $0x8, 0x31(%rbx)
je 0x6c13
cmpl $0x7, %eax
je 0x6bc4
cmpl $0x4, %eax
jne 0x6c13
movl 0x16d52(%rip), %ecx     # 0x1d91c
subl 0x58(%rbx), %ecx
movl 0xf8(%rbx), %esi
leaq 0xa4cb8(%rsi), %rax
mulq %r12
cmpl %ecx, %edx
jae 0x6be9
incb %r14b
xorl %r13d, %r13d
jmp 0x6c13
movzbl 0xff(%rbx), %eax
imulq $0x124f8, %rax, %rax    # imm = 0x124F8
addq %rsi, %rax
mulq %r12
cmpl %ecx, %edx
jae 0x6c13
movq %rbx, %rdi
callq 0xcc81
testb %al, %al
jne 0x6c13
incb 0xff(%rbx)
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x6c50
movl 0x16cf7(%rip), %eax     # 0x1d91c
subl 0x58(%rbx), %eax
movswl 0x78(%rbx), %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,2), %ecx
cmpl %ecx, %eax
jb 0x6c50
movq (%rdi), %r15
callq 0x828a
movq %r15, %rdi
testq %r15, %r15
jne 0x6c35
movq $0x0, 0xb8(%rbx)
movl 0x48(%rbx), %eax
cmpl $0x3, %eax
jne 0x6c68
movl 0x16cbe(%rip), %ecx     # 0x1d91c
subl 0x58(%rbx), %ecx
cmpl $0x29, %ecx
sbbb $-0x1, %r14b
cmpl $0x9, %eax
jne 0x6c7f
movl 0x16ca9(%rip), %eax     # 0x1d91c
subl 0x58(%rbx), %eax
cmpl $0xf1, %eax
sbbb $-0x1, %r14b
testb %r14b, %r14b
je 0x6cb2
movq 0xf0(%rbx), %r15
movq %rbx, %rdi
callq 0x7fc6
movq 0x16c6e(%rip), %rax     # 0x1d908
testq %rbp, %rbp
je 0x6cf2
cmpq %rax, %rbx
je 0x6ec6
movq 0x38(%rbx), %rax
movq %rax, 0x38(%rbp)
jmp 0x6d06
movq 0x38(%rbx), %r13
movb 0x54(%rbx), %al
incb %al
movb %al, 0x54(%rbx)
cmpb 0x55(%rbx), %al
jb 0x69ca
xorl %eax, %eax
movb %al, 0x54(%rbx)
movb %al, 0x16c47(%rip)      # 0x1d919
movq 0xe8(%rbx), %rax
testq %rax, %rax
je 0x6d64
movq 0x40(%rbx), %rdi
movq %rbx, %rsi
callq *%rax
testb %al, %al
sete %al
jmp 0x6d66
cmpq %rbx, %rax
jne 0x6f36
movq 0x38(%rbx), %rax
movq %rax, 0x16c02(%rip)     # 0x1d908
testb %r13b, %r13b
jne 0x6d2f
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 0xc9d6
movq 0x38(%rbx), %r13
movq 0x40(%rbx), %r14
movq %rbx, %rdi
callq 0x685c
movb $0x0, 0x16bd3(%rip)     # 0x1d919
testq %r15, %r15
je 0x6d56
movq %r14, %rdi
movl $0xfffffff3, %esi       # imm = 0xFFFFFFF3
callq *%r15
cmpb $0x0, 0x16bbc(%rip)     # 0x1d919
jne 0x6d6f
jmp 0x69cd
movb $0x1, %al
cmpb $0x0, 0x16bac(%rip)     # 0x1d919
je 0x6d86
movq 0x16b92(%rip), %rbx     # 0x1d908
movl $0x0, %ebp
testq %rbx, %rbx
jne 0x699e
jmp 0x6d9b
testb %al, %al
je 0x69ca
movq %rbx, %rdi
callq 0xbfab
jmp 0x69ca
movq 0x16b6e(%rip), %rbx     # 0x1d910
testq %rbx, %rbx
je 0x6e1c
xorl %r14d, %r14d
cmpl $0xa, 0x48(%rbx)
jne 0x6e88
movl 0x16b62(%rip), %eax     # 0x1d91c
subl 0x58(%rbx), %eax
cmpl $0xf1, %eax
jae 0x6dcd
movq %rbx, %r14
movq 0x38(%rbx), %rbx
jmp 0x6e17
movq %rbx, %rdi
callq 0x7fc6
movq 0x16b34(%rip), %rax     # 0x1d910
testq %r14, %r14
je 0x6df4
cmpq %rax, %rbx
je 0x6ea7
movq 0x38(%rbx), %rax
movq %rax, 0x38(%r14)
jmp 0x6e08
cmpq %rbx, %rax
jne 0x6ee2
movq 0x38(%rbx), %rax
movq %rax, 0x16b08(%rip)     # 0x1d910
movq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x685c
movq %r15, %rbx
testq %rbx, %rbx
jne 0x6daa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe49a(%rip), %rdi      # 0x152cc
leaq 0xf0d2(%rip), %rsi      # 0x15f0b
leaq 0xee5f(%rip), %rcx      # 0x15c9f
movl $0x4c0, %edx            # imm = 0x4C0
jmp 0x6f50
leaq 0xe47b(%rip), %rdi      # 0x152cc
leaq 0xf089(%rip), %rsi      # 0x15ee1
leaq 0xee40(%rip), %rcx      # 0x15c9f
movl $0x4bf, %edx            # imm = 0x4BF
jmp 0x6f50
leaq 0xe45c(%rip), %rdi      # 0x152cc
leaq 0xf040(%rip), %rsi      # 0x15eb7
leaq 0xee21(%rip), %rcx      # 0x15c9f
movl $0x4be, %edx            # imm = 0x4BE
jmp 0x6f50
leaq 0xe43d(%rip), %rdi      # 0x152cc
leaq 0xf15e(%rip), %rsi      # 0x15ff4
leaq 0xee02(%rip), %rcx      # 0x15c9f
movl $0x5a1, %edx            # imm = 0x5A1
jmp 0x6f50
leaq 0xe41e(%rip), %rdi      # 0x152cc
leaq 0xf16e(%rip), %rsi      # 0x16023
leaq 0xede3(%rip), %rcx      # 0x15c9f
movl $0x5af, %edx            # imm = 0x5AF
jmp 0x6f50
leaq 0xe3ff(%rip), %rdi      # 0x152cc
leaq 0xf0cb(%rip), %rsi      # 0x15f9f
leaq 0xedc4(%rip), %rcx      # 0x15c9f
movl $0x56d, %edx            # imm = 0x56D
jmp 0x6f50
leaq 0xe3e3(%rip), %rdi      # 0x152cc
leaq 0xf15a(%rip), %rsi      # 0x1604a
leaq 0xeda8(%rip), %rcx      # 0x15c9f
movl $0x5b3, %edx            # imm = 0x5B3
jmp 0x6f50
leaq 0xe3c7(%rip), %rdi      # 0x152cc
leaq 0xf02c(%rip), %rsi      # 0x15f38
leaq 0xed8c(%rip), %rcx      # 0x15c9f
movl $0x4d4, %edx            # imm = 0x4D4
jmp 0x6f50
leaq 0xe3ab(%rip), %rdi      # 0x152cc
leaq 0xf042(%rip), %rsi      # 0x15f6a
leaq 0xed70(%rip), %rcx      # 0x15c9f
movl $0x4d5, %edx            # imm = 0x4D5
jmp 0x6f50
leaq 0xe38f(%rip), %rdi      # 0x152cc
leaq 0xf086(%rip), %rsi      # 0x15fca
leaq 0xed54(%rip), %rcx      # 0x15c9f
movl $0x571, %edx            # imm = 0x571
xorl %eax, %eax
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
callq 0x2050