// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movb $0x0, -0x15(%rbp)
movl 0x25107(%rip), %eax     # 0x2f91c
addl $0x1, %eax
movl %eax, 0x250fe(%rip)     # 0x2f91c
movb 0x250fc(%rip), %al      # 0x2f920
addb $0x1, %al
movb %al, 0x250f4(%rip)      # 0x2f920
movq $0x0, -0x10(%rbp)
movq 0x250cd(%rip), %rax     # 0x2f908
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa84c
jmp 0xa848
jmp 0xa84a
jmp 0xa84c
jmp 0xa84e
cmpq $0x0, -0x8(%rbp)
je 0xb11f
jmp 0xa85b
jmp 0xa85d
jmp 0xa85f
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0xa89a
jmp 0xa86b
leaq 0x1ca5a(%rip), %rdi     # 0x272cc
leaq 0x1d70a(%rip), %rsi     # 0x27f83
movl $0x4be, %edx            # imm = 0x4BE
leaq 0x1d4e6(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xa89c
jmp 0xa89e
movq -0x8(%rbp), %rax
cmpl $0x1, 0x48(%rax)
jne 0xa8d9
jmp 0xa8aa
leaq 0x1ca1b(%rip), %rdi     # 0x272cc
leaq 0x1d6f5(%rip), %rsi     # 0x27fad
movl $0x4bf, %edx            # imm = 0x4BF
leaq 0x1d4a7(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xa8db
jmp 0xa8dd
movq -0x8(%rbp), %rax
cmpl $0xa, 0x48(%rax)
jne 0xa918
jmp 0xa8e9
leaq 0x1c9dc(%rip), %rdi     # 0x272cc
leaq 0x1d6e0(%rip), %rsi     # 0x27fd7
movl $0x4c0, %edx            # imm = 0x4C0
leaq 0x1d468(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xa91a
movq -0x8(%rbp), %rax
movzbl 0x56(%rax), %eax
movzbl 0x24ff7(%rip), %ecx     # 0x2f920
cmpl %ecx, %eax
jne 0xa946
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa84e
movb 0x24fd4(%rip), %cl      # 0x2f920
movq -0x8(%rbp), %rax
movb %cl, 0x56(%rax)
movb $0x0, -0x13(%rbp)
movb $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x48(%rax)
jne 0xa981
movq -0x8(%rbp), %rax
movzbl 0x7a(%rax), %eax
cmpl $0x6, %eax
jl 0xa981
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0xa97c
jmp 0xad29
movq -0x8(%rbp), %rax
movzbl 0x7a(%rax), %eax
cmpl $0xc, %eax
jl 0xa99d
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0xa998
jmp 0xad27
movq -0x8(%rbp), %rax
movzbl 0xfd(%rax), %eax
cmpl $0x0, %eax
jle 0xab58
jmp 0xa9b3
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0xa9f2
jmp 0xa9c3
leaq 0x1c902(%rip), %rdi     # 0x272cc
leaq 0x1d633(%rip), %rsi     # 0x28004
movl $0x4d4, %edx            # imm = 0x4D4
leaq 0x1d38e(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xa9f4
jmp 0xa9f6
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0xaa35
jmp 0xaa06
leaq 0x1c8bf(%rip), %rdi     # 0x272cc
leaq 0x1d622(%rip), %rsi     # 0x28036
movl $0x4d5, %edx            # imm = 0x4D5
leaq 0x1d34b(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xaa37
movq -0x8(%rbp), %rax
movzbl 0xfe(%rax), %eax
cmpl $0xc, %eax
jl 0xaa54
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0xab53
movq -0x8(%rbp), %rax
movzbl 0xfd(%rax), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1daec(%rip), %rax     # 0x28558
movb (%rax,%rcx), %al
movb %al, -0x16(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xfc(%rax), %eax
movzbl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jge 0xaa98
movq -0x8(%rbp), %rax
movb 0xfc(%rax), %cl
addb $0x1, %cl
movb %cl, 0xfc(%rax)
movq -0x8(%rbp), %rax
movzbl 0xfc(%rax), %eax
movzbl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jl 0xab51
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x98(%rax), %eax
cmpl $0x0, %eax
jne 0xaae0
movq -0x8(%rbp), %rdi
callq 0x16840
movsbl %al, %eax
cmpl $0x0, %eax
je 0xaade
movl $0x0, -0x1c(%rbp)
jmp 0xab18
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x98(%rax), %esi
callq 0x140a0
movsbl %al, %eax
cmpl $0x0, %eax
jne 0xab16
movq -0x8(%rbp), %rdi
callq 0x14b70
movsbl %al, %eax
cmpl $0x0, %eax
jne 0xab14
movl $0x0, -0x1c(%rbp)
jmp 0xab16
jmp 0xab18
cmpl $0x0, -0x1c(%rbp)
je 0xab4f
movq -0x8(%rbp), %rax
movb $0x0, 0xfc(%rax)
movq -0x8(%rbp), %rax
movzbl 0xfd(%rax), %eax
cmpq $0x7, %rax
jae 0xab4d
movq -0x8(%rbp), %rax
movb 0xfd(%rax), %cl
addb $0x1, %cl
movb %cl, 0xfd(%rax)
jmp 0xab4f
jmp 0xab51
jmp 0xab53
jmp 0xad25
movq -0x8(%rbp), %rax
movswl 0x68(%rax), %eax
cmpl $0x0, %eax
jl 0xab84
movq -0x8(%rbp), %rax
movswl 0x68(%rax), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jge 0xab84
movq -0x8(%rbp), %rax
movw 0x68(%rax), %cx
addw $0x1, %cx
movw %cx, 0x68(%rax)
movq -0x8(%rbp), %rax
movswl 0x68(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x78(%rcx), %ecx
cmpl %ecx, %eax
jl 0xad23
jmp 0xab9e
jmp 0xaba0
movq -0x8(%rbp), %rdi
callq 0x15b30
movsbl %al, %eax
cmpl $0x0, %eax
je 0xabd5
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
jne 0xad21
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0xad21
movq -0x8(%rbp), %rax
cmpl $0x2, 0x48(%rax)
je 0xac65
movq -0x8(%rbp), %rax
movzbl 0x7a(%rax), %eax
cmpq $0xc, %rax
jae 0xabff
movq -0x8(%rbp), %rax
movzbl 0x7a(%rax), %eax
movq %rax, -0x58(%rbp)
jmp 0xac0a
movl $0xc, %eax
movq %rax, -0x58(%rbp)
jmp 0xac0a
movq -0x58(%rbp), %rax
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rax
movswl 0x74(%rax), %eax
sarl $0x3, %eax
movq -0x8(%rbp), %rcx
movswl 0x76(%rcx), %ecx
addl %ecx, %eax
movzbl -0x1d(%rbp), %ecx
movl %ecx, %edx
leaq 0x1d92c(%rip), %rcx     # 0x2855f
movzbl (%rcx,%rdx), %ecx
shll %cl, %eax
movl %eax, -0x24(%rbp)
cmpl $0x7fff, -0x24(%rbp)    # imm = 0x7FFF
jge 0xac4d
movl -0x24(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0xac57
movl $0x7fff, %eax           # imm = 0x7FFF
movl %eax, -0x5c(%rbp)
jmp 0xac57
movl -0x5c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x78(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movzwl 0x80(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x98(%rcx), %ecx
cmpl %ecx, %eax
jge 0xac99
movq -0x8(%rbp), %rax
movzwl 0x80(%rax), %eax
movl %eax, -0x60(%rbp)
jmp 0xaca7
movq -0x8(%rbp), %rax
movzwl 0x98(%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
sarl %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x82(%rax)
movq -0x8(%rbp), %rax
movzwl 0x82(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x6a(%rcx), %ecx
shll %ecx
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0xacf6
movq -0x8(%rbp), %rax
movzwl 0x6a(%rax), %eax
shll %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x82(%rax)
movq -0x8(%rbp), %rax
movw 0x6a(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x80(%rax)
jmp 0xad0b
movq -0x8(%rbp), %rax
movw $0x0, 0xa2(%rax)
movq -0x8(%rbp), %rdi
callq 0x15d50
jmp 0xad23
jmp 0xad25
jmp 0xad27
jmp 0xad29
movq -0x8(%rbp), %rax
cmpl $0x6, 0x48(%rax)
jne 0xad65
movq -0x8(%rbp), %rax
movzwl 0x52(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xad63
movl 0x24bd3(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
cmpl $0x28, %eax
jbe 0xad61
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0xad5f
jmp 0xad61
jmp 0xad63
jmp 0xad65
movq -0x8(%rbp), %rax
movzbl 0x31(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xae77
movq -0x8(%rbp), %rax
cmpl $0x4, 0x48(%rax)
je 0xad91
movq -0x8(%rbp), %rax
cmpl $0x7, 0x48(%rax)
jne 0xae77
movl 0x24b85(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
movl %eax, %eax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movl 0xf8(%rax), %eax
addq $0xa4cb8, %rax          # imm = 0xA4CB8
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jbe 0xae01
jmp 0xadcc
jmp 0xadce
jmp 0xadd0
movq -0x8(%rbp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x6, %eax
jne 0xade3
jmp 0xaddf
jmp 0xade1
jmp 0xade9
jmp 0xade5
jmp 0xade7
jmp 0xade9
jmp 0xadeb
jmp 0xaded
jmp 0xadef
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
movb -0x14(%rbp), %al
addb $0x1, %al
movb %al, -0x14(%rbp)
jmp 0xae75
movl 0x24b15(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
movl %eax, %eax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movl 0xf8(%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0xff(%rcx), %ecx
imulq $0x124f8, %rcx, %rcx    # imm = 0x124F8
addq %rcx, %rax
movl $0x1f4, %ecx            # imm = 0x1F4
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jbe 0xae73
movq -0x8(%rbp), %rdi
callq 0x16740
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0xae71
movq -0x8(%rbp), %rax
movb 0xff(%rax), %cl
addb $0x1, %cl
movb %cl, 0xff(%rax)
jmp 0xae73
jmp 0xae75
jmp 0xae77
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0xaeae
movl 0x24a91(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
movq -0x8(%rbp), %rcx
movswl 0x78(%rcx), %ecx
imull $0x6, %ecx, %ecx
cmpl %ecx, %eax
jb 0xaeae
jmp 0xaea3
jmp 0xaea5
movq -0x8(%rbp), %rdi
callq 0xd270
movq -0x8(%rbp), %rax
cmpl $0x3, 0x48(%rax)
jne 0xaed8
movl 0x24a5e(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
cmpl $0x28, %eax
jbe 0xaed6
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0xaed4
jmp 0xaed6
jmp 0xaed8
movq -0x8(%rbp), %rax
cmpl $0x9, 0x48(%rax)
jne 0xaf07
movl 0x24a34(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
movl %eax, %eax
cmpq $0xf0, %rax
jbe 0xaf05
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0xaf03
jmp 0xaf05
jmp 0xaf07
cmpb $0x0, -0x13(%rbp)
je 0xb07e
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd2b0
cmpq $0x0, -0x10(%rbp)
je 0xaf84
jmp 0xaf32
movq -0x8(%rbp), %rax
cmpq 0x249cb(%rip), %rax     # 0x2f908
jne 0xaf70
jmp 0xaf41
leaq 0x1c384(%rip), %rdi     # 0x272cc
leaq 0x1d11c(%rip), %rsi     # 0x2806b
movl $0x56d, %edx            # imm = 0x56D
leaq 0x1ce10(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xaf72
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xafd5
jmp 0xaf86
movq 0x2497b(%rip), %rax     # 0x2f908
cmpq -0x8(%rbp), %rax
je 0xafc4
jmp 0xaf95
leaq 0x1c330(%rip), %rdi     # 0x272cc
leaq 0x1d0f3(%rip), %rsi     # 0x28096
movl $0x571, %edx            # imm = 0x571
leaq 0x1cdbc(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xafc6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x24933(%rip)     # 0x2f908
cmpb $0x0, -0x14(%rbp)
je 0xb019
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x88(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %edx
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %r8
addq $0x18, %r8
movq -0x8(%rbp), %rax
movw 0x4e(%rax), %r9w
movq -0x8(%rbp), %rax
movzwl %r9w, %r9d
movzwl 0x50(%rax), %eax
movl %eax, (%rsp)
callq 0x16110
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rdi
callq 0xa630
movb $0x0, 0x248c6(%rip)     # 0x2f919
cmpq $0x0, -0x38(%rbp)
je 0xb069
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdi
movl $0xfffffff3, %esi       # imm = 0xFFFFFFF3
callq *%rax
jmp 0xb06b
cmpb $0x0, 0x248a7(%rip)     # 0x2f919
je 0xb079
jmp 0xa82c
jmp 0xb11a
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movb 0x54(%rax), %cl
addb $0x1, %cl
movb %cl, 0x54(%rax)
movq -0x10(%rbp), %rax
movzbl 0x54(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x55(%rcx), %ecx
cmpl %ecx, %eax
jl 0xb118
movq -0x10(%rbp), %rax
movb $0x0, 0x54(%rax)
jmp 0xb0bd
movb $0x0, 0x24855(%rip)     # 0x2f919
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
je 0xb0f0
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movb %al, -0x15(%rbp)
jmp 0xb0f4
movb $0x0, -0x15(%rbp)
jmp 0xb0f6
cmpb $0x0, 0x2481c(%rip)     # 0x2f919
je 0xb104
jmp 0xa82c
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0xb116
movq -0x10(%rbp), %rdi
callq 0x14b70
jmp 0xb118
jmp 0xb11a
jmp 0xa84e
movq $0x0, -0x10(%rbp)
movq 0x247e2(%rip), %rax     # 0x2f910
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb296
jmp 0xb13f
movq -0x8(%rbp), %rax
cmpl $0xa, 0x48(%rax)
je 0xb17a
jmp 0xb14b
leaq 0x1c17a(%rip), %rdi     # 0x272cc
leaq 0x1cf67(%rip), %rsi     # 0x280c0
movl $0x5a1, %edx            # imm = 0x5A1
leaq 0x1cc06(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xb17c
movb $0x0, -0x13(%rbp)
movl 0x24796(%rip), %eax     # 0x2f91c
movq -0x8(%rbp), %rcx
subl 0x58(%rcx), %eax
movl %eax, %eax
cmpq $0xf0, %rax
jbe 0xb19f
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
cmpb $0x0, -0x13(%rbp)
je 0xb27d
movq -0x8(%rbp), %rdi
callq 0xd2b0
cmpq $0x0, -0x10(%rbp)
je 0xb20d
jmp 0xb1bb
movq -0x8(%rbp), %rax
cmpq 0x2474a(%rip), %rax     # 0x2f910
jne 0xb1f9
jmp 0xb1ca
leaq 0x1c0fb(%rip), %rdi     # 0x272cc
leaq 0x1cf17(%rip), %rsi     # 0x280ef
movl $0x5af, %edx            # imm = 0x5AF
leaq 0x1cb87(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xb1fb
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xb25e
jmp 0xb20f
movq 0x246fa(%rip), %rax     # 0x2f910
cmpq -0x8(%rbp), %rax
je 0xb24d
jmp 0xb21e
leaq 0x1c0a7(%rip), %rdi     # 0x272cc
leaq 0x1ceea(%rip), %rsi     # 0x28116
movl $0x5b3, %edx            # imm = 0x5B3
leaq 0x1cb33(%rip), %rcx     # 0x27d6b
movb $0x0, %al
callq 0x20d0
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
callq 0x2040
jmp 0xb24f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x246b2(%rip)     # 0x2f910
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x50(%rbp), %rdi
callq 0xa630
jmp 0xb291
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb132
addq $0x80, %rsp
popq %rbp
retq
nop