// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: analyze
static void
analyze (PS * ps)
{
  unsigned open, minlevel, siglevels, l, old, i, orig;
  Lit *this, *other, **p, **q, **eol;
  Var *v, *u, **m, *start, *uip;
  Cls *c;

  assert (ps->conflict);

  assert (ps->ahead == ps->added);
  assert (ps->mhead == ps->marked);
  assert (ps->rhead == ps->resolved);

  /* First, search for First UIP variable and mark all resolved variables.
   * At the same time determine the minimum decision level involved.
   * Increase activities of resolved variables.
   */
  q = ps->thead;
  open = 0;
  minlevel = ps->LEVEL;
  siglevels = 0;
  uip = 0;

  c = ps->conflict;

  for (;;)
    {
      add_antecedent (ps, c);
      inc_activity (ps, c);
      eol = end_of_lits (c);
      for (p = c->lits; p < eol; p++)
	{
	  other = *p;

	  if (other->val == TRUE)
	    continue;

	  assert (other->val == FALSE);

	  u = LIT2VAR (other);
	  if (u->mark)
	    continue;
	  
	  u->mark = 1;
	  inc_score (ps, u);
	  use_var (ps, u);

	  if (u->level == ps->LEVEL)
	    {
	      open++;
	    }
	  else 
	    {
	      push_var_as_marked (ps, u);

	      if (u->level)
		{
		  /* The statistics counter 'nonminimizedllits' sums up the
		   * number of literals that would be added if only the
		   * 'first UIP' scheme for learned clauses would be used
		   * and no clause minimization.
		   */
		  ps->nonminimizedllits++;

		  if (u->level < minlevel)
		    minlevel = u->level;

		  siglevels |= hashlevel (u->level);
		}
	      else
		{
		  assert (!u->level);
		  assert (u->reason);
		}
	    }
	}

      do
	{
	  if (q == ps->trail)
	    {
	      uip = 0;
	      goto DONE_FIRST_UIP;
	    }

	  this = *--q;
	  uip = LIT2VAR (this);
	}
      while (!uip->mark);

      uip->mark = 0;

      c = var2reason (ps, uip);
#ifdef NO_BINARY_CLAUSES
      if (c == &ps->impl)
	resetimpl (ps);
#endif
     open--;
     if ((!open && ps->LEVEL) || !c)
	break;

     assert (c);
    }

DONE_FIRST_UIP:

  if (uip)
    {
      assert (ps->LEVEL);
      this = VAR2LIT (uip);
      this += (this->val == TRUE);
      ps->nonminimizedllits++;
      ps->minimizedllits++;
      add_lit (ps, this);
#ifdef STATS
      if (uip->reason)
	ps->uips++;
#endif
    }
  else
    assert (!ps->LEVEL);

  /* Second, try to mark more intermediate variables, with the goal to
   * minimize the conflict clause.  This is a DFS from already marked
   * variables backward through the implication graph.  It tries to reach
   * other marked variables.  If the search reaches an unmarked decision
   * variable or a variable assigned below the minimum level of variables in
   * the first uip learned clause or a level on which no variable has been
   * marked, then the variable from which the DFS is started is not
   * redundant.  Otherwise the start variable is redundant and will
   * eventually be removed from the learned clause in step 4.  We initially
   * implemented BFS, but then profiling revelead that this step is a bottle
   * neck for certain incremental applications.  After switching to DFS this
   * hot spot went away.
   */
  orig = ps->mhead - ps->marked;
  for (i = 0; i < orig; i++)
    {
      start = ps->marked[i];

      assert (start->mark);
      assert (start != uip);
      assert (start->level < ps->LEVEL);

      if (!start->reason)
	continue;

      old = ps->mhead - ps->marked;
      assert (ps->dhead == ps->dfs);
      push (ps, start);

      while (ps->dhead > ps->dfs)
	{
	  u = pop (ps);
	  assert (u->mark);

	  c = var2reason (ps, u);
#ifdef NO_BINARY_CLAUSES
	  if (c == &ps->impl)
	    resetimpl (ps);
#endif
	  if (!c || 
	      ((l = u->level) && 
	       (l < minlevel || ((hashlevel (l) & ~siglevels)))))
	    {
	      while (ps->mhead > ps->marked + old)	/* reset all marked */
		(*--ps->mhead)->mark = 0;

	      ps->dhead = ps->dfs;		/* and DFS stack */
	      break;
	    }

	  eol = end_of_lits (c);
	  for (p = c->lits; p < eol; p++)
	    {
	      v = LIT2VAR (*p);
	      if (v->mark)
		continue;

	      mark_var (ps, v);
	      push (ps, v);
	    }
	}
    }

  for (m = ps->marked; m < ps->mhead; m++)
    {
      v = *m;

      assert (v->mark);
      assert (!v->resolved);

      use_var (ps, v);

      c = var2reason (ps, v);
      if (!c)
	continue;

#ifdef NO_BINARY_CLAUSES
      if (c == &ps->impl)
	resetimpl (ps);
#endif
      eol = end_of_lits (c);
      for (p = c->lits; p < eol; p++)
	{
	  other = *p;

	  u = LIT2VAR (other);
	  if (!u->level)
	    continue;

	  if (!u->mark)		/* 'MARKTEST' */
	    break;
	}

      if (p != eol)
	continue;

      add_antecedent (ps, c);
      v->resolved = 1;
    }

  for (m = ps->marked; m < ps->mhead; m++)
    {
      v = *m;

      assert (v->mark);
      v->mark = 0;

      if (v->resolved)
	{
	  v->resolved = 0;
	  continue;
	}

      this = VAR2LIT (v);
      if (this->val == TRUE)
	this++;			/* actually NOTLIT */

      add_lit (ps, this);
      ps->minimizedllits++;
    }

  assert (ps->ahead <= ps->eoa);
  assert (ps->rhead <= ps->eor);

  ps->mhead = ps->marked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
je 0x16b4f
jmp 0x16b6e
leaq 0x791e(%rip), %rdi      # 0x1e474
leaq 0x6747(%rip), %rsi      # 0x1d2a4
movl $0xdaa, %edx            # imm = 0xDAA
leaq 0x8281(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x258(%rcx), %rax
jne 0x16b88
jmp 0x16ba7
leaq 0x7c75(%rip), %rdi      # 0x1e804
leaq 0x670e(%rip), %rsi      # 0x1d2a4
movl $0xdac, %edx            # imm = 0xDAC
leaq 0x8248(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x270(%rcx), %rax
jne 0x16bc1
jmp 0x16be0
leaq 0x74e6(%rip), %rdi      # 0x1e0ae
leaq 0x66d5(%rip), %rsi      # 0x1d2a4
movl $0xdad, %edx            # imm = 0xDAD
leaq 0x820f(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2a0(%rcx), %rax
jne 0x16bfa
jmp 0x16c19
leaq 0x7bb9(%rip), %rdi      # 0x1e7ba
leaq 0x669c(%rip), %rsi      # 0x1d2a4
movl $0xdae, %edx            # imm = 0xDAE
leaq 0x81d6(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x14060
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x17990
movq -0x80(%rbp), %rdi
callq 0xb980
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x16e2b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x16cb4
jmp 0x16e1a
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x16cc2
jmp 0x16ce1
leaq 0x7dbb(%rip), %rdi      # 0x1ea84
leaq 0x65d4(%rip), %rsi      # 0x1d2a4
movl $0xdc8, %edx            # imm = 0xDC8
leaq 0x810e(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x16d1f
jmp 0x16e1a
movq -0x60(%rbp), %rax
movw (%rax), %cx
andw $-0x2, %cx
orw $0x1, %cx
movw %cx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x17a60
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x13c50
movq -0x60(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x16d69
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16e18
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x17b90
movq -0x60(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x16dbd
movq -0x8(%rbp), %rax
movl 0x464(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x464(%rax)
movq -0x60(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jae 0x16da9
movq -0x60(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x60(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x17d10
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x16e16
movq -0x60(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x16dc9
jmp 0x16de8
leaq 0x802d(%rip), %rdi      # 0x1edfd
leaq 0x64cd(%rip), %rsi      # 0x1d2a4
movl $0xdea, %edx            # imm = 0xDEA
leaq 0x8007(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x60(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16df5
jmp 0x16e14
leaq 0x800b(%rip), %rdi      # 0x1ee07
leaq 0x64a1(%rip), %rsi      # 0x1d2a4
movl $0xdeb, %edx            # imm = 0xDEB
leaq 0x7fdb(%rip), %rcx      # 0x1edea
callq 0x10b0
jmp 0x16e16
jmp 0x16e18
jmp 0x16e1a
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x16c8a
jmp 0x16e2d
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0xc8(%rcx), %rax
jne 0x16e4b
movq $0x0, -0x78(%rbp)
jmp 0x16f30
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, -0x48(%rbp)
movq -0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16e2d
movq -0x78(%rbp), %rax
movw (%rax), %cx
andw $-0x2, %cx
orw $0x0, %cx
movw %cx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x17d30
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x70, %rcx
cmpq %rcx, %rax
jne 0x16edf
movq -0x8(%rbp), %rdi
callq 0x13ec0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x16ef8
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x16eff
cmpq $0x0, -0x80(%rbp)
jne 0x16f01
jmp 0x16f2e
cmpq $0x0, -0x80(%rbp)
je 0x16f0a
jmp 0x16f29
leaq 0x5a76(%rip), %rdi      # 0x1c987
leaq 0x638c(%rip), %rsi      # 0x1d2a4
movl $0xe08, %edx            # imm = 0xE08
leaq 0x7ec6(%rip), %rcx      # 0x1edea
callq 0x10b0
jmp 0x16c57
jmp 0x16f30
cmpq $0x0, -0x78(%rbp)
je 0x16fe0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x16f47
jmp 0x16f66
leaq 0x7eeb(%rip), %rdi      # 0x1ee39
leaq 0x634f(%rip), %rsi      # 0x1d2a4
movl $0xe0f, %edx            # imm = 0xE0F
leaq 0x7e89(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x78(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x464(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x464(%rax)
movq -0x8(%rbp), %rax
movl 0x460(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x460(%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6c80
jmp 0x1700d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x16fec
jmp 0x1700b
leaq 0x74a6(%rip), %rdi      # 0x1e499
leaq 0x62aa(%rip), %rsi      # 0x1d2a4
movl $0xe1b, %edx            # imm = 0xE1B
leaq 0x7de4(%rip), %rcx      # 0x1edea
callq 0x10b0
jmp 0x1700d
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x270(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x17328
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1706b
jmp 0x1708a
leaq 0x7d9f(%rip), %rdi      # 0x1ee11
leaq 0x622b(%rip), %rsi      # 0x1d2a4
movl $0xe2f, %edx            # imm = 0xE2F
leaq 0x7d65(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x70(%rbp), %rax
cmpq -0x78(%rbp), %rax
je 0x17096
jmp 0x170b5
leaq 0x7d80(%rip), %rdi      # 0x1ee1d
leaq 0x6200(%rip), %rsi      # 0x1d2a4
movl $0xe30, %edx            # imm = 0xE30
leaq 0x7d3a(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x170c7
jmp 0x170e6
leaq 0x7d5c(%rip), %rdi      # 0x1ee2a
leaq 0x61cf(%rip), %rsi      # 0x1d2a4
movl $0xe31, %edx            # imm = 0xE31
leaq 0x7d09(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x70(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x170f6
jmp 0x1731a
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x270(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x290(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x288(%rcx), %rax
jne 0x17130
jmp 0x1714f
leaq 0x7d0c(%rip), %rdi      # 0x1ee43
leaq 0x6166(%rip), %rsi      # 0x1d2a4
movl $0xe37, %edx            # imm = 0xE37
leaq 0x7ca0(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x17e60
movq -0x8(%rbp), %rax
movq 0x290(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x288(%rcx), %rax
jbe 0x17318
movq -0x8(%rbp), %rdi
callq 0x17fe0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1719a
jmp 0x171b9
leaq 0x7cb7(%rip), %rdi      # 0x1ee58
leaq 0x60fc(%rip), %rsi      # 0x1d2a4
movl $0xe3d, %edx            # imm = 0xE3D
leaq 0x7c36(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x17d30
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x70, %rcx
cmpq %rcx, %rax
jne 0x171e4
movq -0x8(%rbp), %rdi
callq 0x13ec0
cmpq $0x0, -0x80(%rbp)
je 0x1721b
movq -0x60(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x1728a
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jb 0x1721b
movl -0x18(%rbp), %edi
callq 0x17d10
movl -0x14(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1728a
jmp 0x1721d
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x270(%rcx), %rcx
movl -0x1c(%rbp), %edx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x1726f
movq -0x8(%rbp), %rcx
movq 0x278(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x278(%rcx)
movq -0x8(%rax), %rax
movw (%rax), %cx
andw $-0x2, %cx
orw $0x0, %cx
movw %cx, (%rax)
jmp 0x1721d
movq -0x8(%rbp), %rax
movq 0x288(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x290(%rax)
jmp 0x17318
movq -0x80(%rbp), %rdi
callq 0xb980
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x17313
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x172eb
jmp 0x17305
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x18050
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x17e60
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x172a3
jmp 0x1715c
jmp 0x1731a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17034
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x278(%rcx), %rax
jae 0x174c7
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1736c
jmp 0x1738b
leaq 0x7c6a(%rip), %rdi      # 0x1efdd
leaq 0x5f2a(%rip), %rsi      # 0x1d2a4
movl $0xe60, %edx            # imm = 0xE60
leaq 0x7a64(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x58(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x173a3
jmp 0x173c2
leaq 0x7ab6(%rip), %rdi      # 0x1ee60
leaq 0x5ef3(%rip), %rsi      # 0x1d2a4
movl $0xe61, %edx            # imm = 0xE61
leaq 0x7a2d(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x13c50
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x17d30
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x173ec
jmp 0x174b6
movq -0x80(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x70, %rcx
cmpq %rcx, %rax
jne 0x17406
movq -0x8(%rbp), %rdi
callq 0x13ec0
movq -0x80(%rbp), %rdi
callq 0xb980
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x1748b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x17466
jmp 0x1747d
movq -0x60(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x1747b
jmp 0x1748b
jmp 0x1747d
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x1741f
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x17497
jmp 0x174b6
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x14060
movq -0x58(%rbp), %rax
movw (%rax), %cx
andw $-0x3, %cx
orw $0x2, %cx
movw %cx, (%rax)
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x17337
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x278(%rcx), %rax
jae 0x175d4
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1750b
jmp 0x1752a
leaq 0x7acb(%rip), %rdi      # 0x1efdd
leaq 0x5d8b(%rip), %rsi      # 0x1d2a4
movl $0xe85, %edx            # imm = 0xE85
leaq 0x78c5(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x58(%rbp), %rax
movw (%rax), %cx
andw $-0x2, %cx
orw $0x0, %cx
movw %cx, (%rax)
movq -0x58(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x17566
movq -0x58(%rbp), %rax
movw (%rax), %cx
andw $-0x3, %cx
orw $0x0, %cx
movw %cx, (%rax)
jmp 0x175c3
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x58(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x175a3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6c80
movq -0x8(%rbp), %rax
movl 0x460(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x460(%rax)
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x174d6
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x268(%rcx), %rax
ja 0x175ee
jmp 0x1760d
leaq 0x7878(%rip), %rdi      # 0x1ee6d
leaq 0x5ca8(%rip), %rsi      # 0x1d2a4
movl $0xe96, %edx            # imm = 0xE96
leaq 0x77e2(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2b0(%rcx), %rax
ja 0x17627
jmp 0x17646
leaq 0x7854(%rip), %rdi      # 0x1ee82
leaq 0x5c6f(%rip), %rsi      # 0x1d2a4
movl $0xe97, %edx            # imm = 0xE97
leaq 0x77a9(%rip), %rcx      # 0x1edea
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x278(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)