// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: add_simplified_clause
static Cls *
add_simplified_clause (PS * ps, int learned)
{
  unsigned num_true, num_undef, num_false, size, count_resolved;
  Lit **p, **q, *lit, ** end;
  unsigned litlevel, glue;
  Cls *res, * reason;
  int reentered;
  Val val;
  Var *v;
#if !defined(NDEBUG) && defined(TRACE)
  unsigned idx;
#endif

  reentered = 0;

REENTER:

  size = ps->ahead - ps->added;

  add_resolved (ps, learned);

  if (learned)
    {
      ps->ladded++;
      ps->llitsadded += size;
      if (size > 2)
	{
	  ps->lladded++;
	  ps->nlclauses++;
	  ps->llits += size;
	}
    }
  else
    {
      ps->oadded++;
      if (size > 2)
	{
	  ps->loadded++;
	  ps->noclauses++;
	  ps->olits += size;
	}
    }

  ps->addedclauses++;
  assert (ps->addedclauses == ps->ladded + ps->oadded);

#ifdef NO_BINARY_CLAUSES
  if (size == 2)
    res = setimpl (ps, ps->added[0], ps->added[1]);
  else
#endif
    {
      sortlits (ps, ps->added, size); 

      if (learned)
	{
	  if (ps->lhead == ps->EOL)
	    {
	      ENLARGE (ps->lclauses, ps->lhead, ps->EOL);

	      /* A very difficult to find bug, which only occurs if the
	       * learned clauses stack is immediately allocated before the
	       * original clauses stack without padding.  In this case, we
	       * have 'SOC == EOC', which terminates all loops using the
	       * idiom 'for (p = SOC; p != EOC; p = NXC(p))' immediately.
	       * Unfortunately this occurred in 'fix_clause_lits' after
	       * using a recent version of the memory allocator of 'Google'
	       * perftools in the context of one large benchmark for 
	       * our SMT solver 'Boolector'.
	       */
	      if (ps->EOL == ps->oclauses)
		ENLARGE (ps->lclauses, ps->lhead, ps->EOL);
	    }

#if !defined(NDEBUG) && defined(TRACE)
	  idx = LIDX2IDX (ps->lhead - ps->lclauses);
#endif
	}
      else
	{
	  if (ps->ohead == ps->eoo)
	    {
	      ENLARGE (ps->oclauses, ps->ohead, ps->eoo);
	      if (ps->EOL == ps->oclauses)
		ENLARGE (ps->oclauses, ps->ohead, ps->eoo);	/* ditto */
	    }

#if !defined(NDEBUG) && defined(TRACE)
	  idx = OIDX2IDX (ps->ohead - ps->oclauses);
#endif
	}

      assert (ps->EOL != ps->oclauses);			/* ditto */

      res = new_clause (ps, size, learned);

      glue = 0;

      if (learned)
	{
	  assert (ps->dusedhead == ps->dused);

	  for (p = ps->added; p < ps->ahead; p++) 
	    {
	      lit = *p;
	      if (lit->val)
		{
		  litlevel = LIT2VAR (lit)->level;
		  assert (litlevel <= ps->LEVEL);
		  while (ps->levels + litlevel >= ps->levelshead)
		    {
		      if (ps->levelshead >= ps->eolevels)
			ENLARGE (ps->levels, ps->levelshead, ps->eolevels);
		      assert (ps->levelshead < ps->eolevels);
		      *ps->levelshead++ = 0;
		    }
		  if (!ps->levels[litlevel])
		    {
		      if (ps->dusedhead >= ps->eodused)
			ENLARGE (ps->dused, ps->dusedhead, ps->eodused);
		      assert (ps->dusedhead < ps->eodused);
		      *ps->dusedhead++ = litlevel;
		      ps->levels[litlevel] = 1;
		      glue++;
		    }
		}
	      else
		glue++;
	    }

	  while (ps->dusedhead > ps->dused) 
	    {
	      litlevel = *--ps->dusedhead;
	      assert (ps->levels + litlevel < ps->levelshead);
	      assert (ps->levels[litlevel]);
	      ps->levels[litlevel] = 0;
	    }
	}

      assert (glue <= MAXGLUE);
      res->glue = glue;

#if !defined(NDEBUG) && defined(TRACE)
      if (ps->trace)
	assert (CLS2IDX (res) == idx);
#endif
      if (learned)
	*ps->lhead++ = res;
      else
	*ps->ohead++ = res;

#if !defined(NDEBUG) && defined(TRACE)
      if (ps->trace && learned)
	assert (ps->zhead - ps->zhains == ps->lhead - ps->lclauses);
#endif
      assert (ps->lhead != ps->oclauses);		/* ditto */
    }

  if (learned && ps->rup)
    {
      if (!ps->rupstarted)
	{
	  write_rup_header (ps, ps->rup);
	  ps->rupstarted = 1;
	}
    }

  num_true = num_undef = num_false = 0;

  q = res->lits;
  for (p = ps->added; p < ps->ahead; p++)
    {
      lit = *p;
      *q++ = lit;

      if (learned && ps->rup)
	fprintf (ps->rup, "%d ", LIT2INT (lit));

      val = lit->val;

      num_true += (val == TRUE);
      num_undef += (val == UNDEF);
      num_false += (val == FALSE);
    }
  assert (num_false + num_true + num_undef == size);

  if (learned && ps->rup)
    fputs ("0\n", ps->rup);

  ps->ahead = ps->added;		/* reset */

  if (!reentered)				// TODO merge
  if (size > 0)
    {
      assert (size <= 2 || !reentered);		// TODO remove
      connect_head_tail (ps, res->lits[0], res);
      if (size > 1)
	connect_head_tail (ps, res->lits[1], res);
    }

  if (size == 0)
    {
      if (!ps->mtcls)
	ps->mtcls = res;
    }

#ifdef NO_BINARY_CLAUSES
  if (size != 2)
#endif
#ifndef NDEBUG
    res->connected = 1;
#endif

  LOG ( fprintf (ps->out, "%s%s ", ps->prefix, learned ? "learned" : "original");
        dumpclsnl (ps, res));

  /* Shrink clause by resolving it against top level assignments.
   */
  if (!ps->LEVEL && num_false > 0)
    {
      assert (ps->ahead == ps->added);
      assert (ps->rhead == ps->resolved);

      count_resolved = 1;
      add_antecedent (ps, res);

      end = end_of_lits (res);
      for (p = res->lits; p < end; p++)
	{
	  lit = *p;
	  v = LIT2VAR (lit);
	  use_var (ps, v);

	  if (lit->val == FALSE)
	    {
	      add_antecedent (ps, v->reason);
	      count_resolved++;
	    }
	  else
	    add_lit (ps, lit);
	}

      assert (count_resolved >= 2);

      learned = 1;
#ifdef NO_BINARY_CLAUSES
      if (res == &ps->impl)
	resetimpl (ps);
#endif
      reentered = 1;
      goto REENTER;		/* and return simplified clause */
    }

  if (!num_true && num_undef == 1)	/* unit clause */
    {
      lit = 0;
      for (p = res->lits; p < res->lits + size; p++)
	{
	  if ((*p)->val == UNDEF)
	    lit = *p;

	  v = LIT2VAR (*p);
	  use_var (ps, v);
	}
      assert (lit);

      reason = res;
#ifdef NO_BINARY_CLAUSES
      if (size == 2)
        {
	  Lit * other = res->lits[0];
	  if (other == lit)
	    other = res->lits[1];

	  assert (other->val == FALSE);
	  reason = LIT2REASON (NOTLIT (other));
	}
#endif
      assign_forced (ps, lit, reason);
      num_true++;
    }

  if (num_false == size && !ps->conflict)
    {
#ifdef NO_BINARY_CLAUSES
      if (res == &ps->impl)
	ps->conflict = setcimpl (ps, res->lits[0], res->lits[1]);
      else
#endif
      ps->conflict = res;
    }

  if (!learned && !num_true && num_undef)
    incjwh (ps, res);

#ifdef NO_BINARY_CLAUSES
  if (res == &ps->impl)
    resetimpl (ps);
#endif
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r12
leaq 0x200(%rdi), %rax
movq %rax, 0x50(%rsp)
leaq 0x1e8(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0x70(%rdi), %rax
movq %rax, 0x28(%rsp)
movb $0x1, %al
movq %rdi, (%rsp)
movl %eax, 0x44(%rsp)
movq 0x258(%r12), %rdi
movq 0x260(%r12), %rcx
subq %rdi, %rcx
shrq $0x3, %rcx
movq 0x2a0(%r12), %rax
movq %rax, 0x2a8(%r12)
movl %esi, 0x14(%rsp)
testl %esi, %esi
je 0xd89e
incl 0x43c(%r12)
addl %ecx, 0x450(%r12)
cmpl $0x3, %ecx
jb 0xd8c3
incl 0x444(%r12)
incl 0x42c(%r12)
addl %ecx, 0x434(%r12)
jmp 0xd8c3
incl 0x438(%r12)
cmpl $0x3, %ecx
jb 0xd8c3
incl 0x440(%r12)
incl 0x428(%r12)
addl %ecx, 0x430(%r12)
movq %rcx, 0x18(%rsp)
movl 0x438(%r12), %eax
movl 0x448(%r12), %ecx
incl %ecx
movl %ecx, 0x448(%r12)
addl 0x43c(%r12), %eax
cmpl %eax, %ecx
jne 0xe740
cmpl $0x2, 0x18(%rsp)
jne 0xd912
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %r12, %rdi
callq 0xd613
movq %rax, 0x8(%rsp)
jmp 0xe20b
movq 0x478(%r12), %rax
cmpq 0x470(%r12), %rax
jne 0xe75f
movq 0x18(%rsp), %rax
leal -0x1(%rax), %ecx
movq %rcx, 0x30(%rsp)
cmpl $0xc, %eax
movq %rdi, 0x8(%rsp)
jge 0xdb12
movl 0x30(%rsp), %ebx
testl %ebx, %ebx
jle 0xd97b
movq -0x8(%rdi,%rbx,8), %rsi
movq (%rdi,%rbx,8), %rdx
movq %r12, %rdi
callq 0xec24
movq 0x8(%rsp), %rdi
testl %eax, %eax
jle 0xd976
movdqu -0x8(%rdi,%rbx,8), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, -0x8(%rdi,%rbx,8)
decq %rbx
jmp 0xd947
movslq 0x18(%rsp), %rbx
leaq 0x10(%rdi), %r14
pushq $0x2
popq %r12
cmpq %rbx, %r12
jge 0xd9c8
movq (%rdi,%r12,8), %r15
movq %r14, %r13
movq -0x8(%r13), %rdx
movq (%rsp), %rdi
movq %r15, %rsi
callq 0xec24
testl %eax, %eax
jns 0xd9b6
movq -0x8(%r13), %rax
movq %rax, (%r13)
addq $-0x8, %r13
jmp 0xd994
movq %r15, (%r13)
incq %r12
addq $0x8, %r14
movq 0x8(%rsp), %rdi
jmp 0xd988
movq (%rsp), %r12
movq 0x478(%r12), %rax
cmpq 0x470(%r12), %rax
jne 0xe75f
movq 0x30(%rsp), %r14
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
shlq $0x3, %r14
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0xda21
movq (%rdi,%rbx), %rsi
movq 0x8(%rdi,%rbx), %rdx
movq %r12, %rdi
callq 0xec24
movq 0x8(%rsp), %rdi
addq $0x8, %rbx
testl %eax, %eax
jle 0xd9f9
jmp 0xe67d
cmpl $0x0, 0x14(%rsp)
je 0xde3b
movq 0x200(%r12), %rdx
cmpq 0x208(%r12), %rdx
jne 0xdf18
movq 0x1f8(%r12), %rsi
cmpq %rdx, %rsi
ja 0xe882
subq %rsi, %rdx
movq %rdx, %r14
shrq $0x3, %r14
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
andq %rcx, %rdx
movl %eax, %ebx
pushq $0x1
popq %rax
cmoveq %rax, %rbx
leaq (,%rbx,8), %r15
movq %r12, %rdi
movq %r15, %rcx
callq 0x3e40
movq %rax, 0x1f8(%r12)
movl %r14d, %r14d
leaq (%rax,%r14,8), %rcx
movq %rcx, 0x200(%r12)
leaq (%rax,%rbx,8), %rcx
movq %rcx, 0x208(%r12)
cmpq 0x1e0(%r12), %rcx
jne 0xdf18
leal (%rbx,%rbx), %r12d
testq %rbx, %rbx
pushq $0x1
popq %rcx
cmoveq %rcx, %r12
leaq (,%r12,8), %rcx
movq (%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3e40
movq (%rsp), %rcx
movq %rax, 0x1f8(%rcx)
leaq (%rax,%r14,8), %rcx
movq (%rsp), %rdx
movq %rcx, 0x200(%rdx)
leaq (%rax,%r12,8), %rax
movq (%rsp), %r12
movq %rax, 0x208(%r12)
jmp 0xdf18
xorl %r14d, %r14d
movq 0x30(%rsp), %rax
movl %eax, %r8d
leal (%r14,%r8), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movq %r8, 0x60(%rsp)
movslq %r8d, %r13
movq -0x8(%rdi,%r13,8), %rcx
cltq
movq (%rdi,%rax,8), %rdx
movq %rdx, -0x8(%rdi,%r13,8)
movq %rcx, (%rdi,%rax,8)
movslq %r14d, %rbx
movq (%rdi,%rbx,8), %rsi
movq -0x8(%rdi,%r13,8), %rdx
movq %r12, %rdi
callq 0xec24
movq 0x8(%rsp), %rcx
movq (%rcx,%rbx,8), %rsi
testl %eax, %eax
jle 0xdb75
movq -0x8(%rcx,%r13,8), %rax
movq %rsi, -0x8(%rcx,%r13,8)
movq %rax, (%rcx,%rbx,8)
movq %rax, %rsi
movq (%rcx,%r13,8), %rdx
movq %r12, %rdi
callq 0xec24
movq 0x8(%rsp), %rdx
testl %eax, %eax
jle 0xdb9a
movq (%rdx,%r13,8), %rax
movq (%rdx,%rbx,8), %rcx
movq %rcx, (%rdx,%r13,8)
movq %rax, (%rdx,%rbx,8)
movq -0x8(%rdx,%r13,8), %rsi
movq (%rdx,%r13,8), %rdx
movq %r12, %rdi
callq 0xec24
movq 0x8(%rsp), %rdi
testl %eax, %eax
jle 0xdbc7
movdqu -0x8(%rdi,%r13,8), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, -0x8(%rdi,%r13,8)
leal -0x1(%r13), %ebp
movq -0x8(%rdi,%r13,8), %r15
decq %r13
movq %r13, 0x58(%rsp)
leal 0x2(%r14), %eax
movslq %eax, %rbx
movq %r14, 0x38(%rsp)
movl %r14d, %r10d
movq %r10, 0x68(%rsp)
movslq %r10d, %rax
movq %rax, 0x20(%rsp)
leaq (%rdi,%rax,8), %r14
xorl %r13d, %r13d
movq 0x8(%r14,%r13,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xec24
incq %r13
testl %eax, %eax
js 0xdbfb
movslq %ebp, %rbp
addq %r13, 0x20(%rsp)
movq %rbp, %r12
decq %rbp
movq 0x8(%rsp), %rax
movq -0x8(%rax,%r12,8), %rdx
movq (%rsp), %rdi
movq %r15, %rsi
callq 0xec24
cmpq %r12, %rbx
je 0xdc3f
testl %eax, %eax
js 0xdc1a
cmpq %rbp, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %r10
jge 0xdc6f
movl %r10d, %r10d
addq %r13, %r10
movq (%rdi,%rbp,8), %rax
movq (%r14,%r13,8), %rcx
movq %rcx, (%rdi,%rbp,8)
movq %rax, (%r14,%r13,8)
movq (%rsp), %r12
jmp 0xdbe7
leal (%r10,%r13), %eax
decl %eax
movq 0x58(%rsp), %rsi
movq (%rdi,%rsi,8), %rcx
movq (%r14,%r13,8), %rdx
movq %rdx, (%rdi,%rsi,8)
leal (%r10,%r13), %edx
movq 0x38(%rsp), %r9
subl %r9d, %edx
movq 0x60(%rsp), %r8
movl %r8d, %esi
subl %r10d, %esi
subl %r13d, %esi
cmpl %esi, %edx
leal 0x1(%r10,%r13), %edx
movl %eax, %r12d
cmovll %r8d, %r12d
movl %r9d, %ebx
cmovll %edx, %ebx
cmovll %eax, %r8d
movq %rcx, (%r14,%r13,8)
movq %r9, %r14
cmovgel %edx, %r14d
movl %r8d, %ecx
subl %r14d, %ecx
movl %r12d, %eax
subl %ebx, %eax
cmpl $0xb, %ecx
jl 0xddf9
cmpl $0xa, %eax
jle 0xe674
movq (%rsp), %rbp
movq 0x478(%rbp), %r13
movq 0x480(%rbp), %r15
cmpq %r15, %r13
jne 0xdd64
movq 0x470(%rbp), %rsi
cmpq %r13, %rsi
ja 0xe6c4
subq %rsi, %r13
movq %r13, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %r13
movq %r14, 0x38(%rsp)
movl %eax, %r14d
pushq $0x1
popq %rax
cmoveq %rax, %r14
leaq (,%r14,4), %rcx
movq %rbp, %rdi
movq %r13, %rdx
movq %r8, %r15
callq 0x3e40
movq %r15, %r8
movq 0x8(%rsp), %rdi
movq %rax, 0x470(%rbp)
addq %rax, %r13
leaq (%rax,%r14,4), %r15
movq 0x38(%rsp), %r14
movq %r15, 0x480(%rbp)
leaq 0x4(%r13), %rax
movq %rax, 0x478(%rbp)
movl %ebx, (%r13)
cmpq %r15, %rax
jne 0xdde3
movq 0x470(%rbp), %rsi
cmpq %r15, %rsi
ja 0xe6c4
subq %rsi, %r15
movq %r15, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %r15
movl %eax, %ebx
pushq $0x1
popq %rax
cmoveq %rax, %rbx
leaq (,%rbx,4), %rcx
movq %rbp, %rdi
movq %r15, %rdx
movq %r14, %r13
movq %r8, %r14
callq 0x3e40
movq %r14, %r8
movq %r13, %r14
movq 0x8(%rsp), %rdi
movq %rax, 0x470(%rbp)
addq %rax, %r15
leaq (%rax,%rbx,4), %rax
movq %rax, 0x480(%rbp)
movq %r15, %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x478(%rbp)
movl %r12d, (%rax)
movq %rbp, %r12
jmp 0xdb1d
movl %r12d, %r8d
movl %ebx, %r14d
cmpl $0xa, %eax
movq (%rsp), %r12
jg 0xdb1d
movq 0x478(%r12), %rax
cmpq 0x470(%r12), %rax
jbe 0xd943
movl -0x4(%rax), %r8d
leaq -0x8(%rax), %rcx
movq %rcx, 0x478(%r12)
movl -0x8(%rax), %r14d
jmp 0xdb1d
movq 0x1e8(%r12), %rdx
cmpq 0x1f0(%r12), %rdx
jne 0xdf18
movq 0x1e0(%r12), %rsi
cmpq %rdx, %rsi
ja 0xe8a1
subq %rsi, %rdx
movq %rdx, %r14
shrq $0x3, %r14
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
andq %rcx, %rdx
movl %eax, %ebx
pushq $0x1
popq %rax
cmoveq %rax, %rbx
leaq (,%rbx,8), %r15
movq %r12, %rdi
movq %r15, %rcx
callq 0x3e40
movq %rax, 0x1e0(%r12)
movl %r14d, %r14d
leaq (%rax,%r14,8), %rcx
movq %rcx, 0x1e8(%r12)
leaq (%rax,%rbx,8), %rcx
movq %rcx, 0x1f0(%r12)
cmpq %rax, 0x208(%r12)
jne 0xdf18
leal (%rbx,%rbx), %r12d
testq %rbx, %rbx
pushq $0x1
popq %rcx
cmoveq %rcx, %r12
leaq (,%r12,8), %rcx
movq (%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3e40
movq (%rsp), %rcx
movq %rax, 0x1e0(%rcx)
leaq (%rax,%r14,8), %rcx
movq (%rsp), %rdx
movq %rcx, 0x1e8(%rdx)
leaq (%rax,%r12,8), %rax
movq (%rsp), %r12
movq %rax, 0x1f0(%r12)
movq 0x208(%r12), %rax
cmpq 0x1e0(%r12), %rax
je 0xe7e7
movq 0x18(%rsp), %r15
movl %r15d, %ebx
movl 0x14(%rsp), %ebp
testl %ebp, %ebp
setne %al
cmpl $0x3, %r15d
setae %cl
andb %al, %cl
movzbl %cl, %r14d
leal (,%r14,4), %eax
leaq (%rax,%rbx,8), %rsi
addq $0x18, %rsi
movq %r12, %rdi
callq 0x8f50
movl %r15d, (%rax)
movl 0x4(%rax), %esi
movl %ebp, %ecx
andl $0x1, %ecx
movl %esi, %edx
andl $-0x20, %edx
leal (%rdx,%rcx,2), %ecx
movq %rax, 0x8(%rsp)
movl %ecx, 0x4(%rax)
cmpb $0x1, %r14b
jne 0xdfa2
testb $0x1, %bpl
je 0xe863
movl 0x310(%r12), %eax
movq 0x8(%rsp), %rcx
movl %eax, 0x18(%rcx,%rbx,8)
jmp 0xdfaa
testl %ebp, %ebp
je 0xe1d5
movq 0x2d8(%r12), %rax
cmpq 0x2d0(%r12), %rax
jne 0xe825
movq 0x258(%r12), %r14
xorl %ebp, %ebp
cmpq 0x260(%r12), %r14
jae 0xe192
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0xe156
movq 0x40(%r12), %rcx
subl 0x38(%r12), %eax
shrl %eax
shlq $0x4, %rax
movq %r12, %rdx
movl 0x4(%rcx,%rax), %r12d
cmpl 0x28(%rdx), %r12d
ja 0xe6e3
movq (%rsp), %rcx
movq 0x2b8(%rcx), %rsi
movq 0x2c0(%rcx), %rbx
leaq (%rsi,%r12), %rax
cmpq %rbx, %rax
jb 0xe09b
movq 0x2c8(%rcx), %rdx
cmpq %rdx, %rbx
jb 0xe07b
cmpq %rdx, %rsi
ja 0xe655
subl %esi, %ebx
subq %rsi, %rdx
leal (%rdx,%rdx), %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
andq %rax, %rdx
pushq $0x1
popq %rax
cmoveq %rax, %r13
movq (%rsp), %r15
movq %r15, %rdi
movq %r13, %rcx
callq 0x3e40
movq %rax, 0x2b8(%r15)
addq %rax, %rbx
movq %rbx, 0x2c0(%r15)
addq %rax, %r13
movq %r13, 0x2c8(%r15)
movq %r13, %rdx
cmpq %rdx, %rbx
jae 0xe636
leaq 0x1(%rbx), %rax
movq (%rsp), %rcx
movq %rax, 0x2c0(%rcx)
movb $0x0, (%rbx)
jmp 0xe00a
cmpb $0x0, (%rax)
je 0xe0a9
movq (%rsp), %r12
jmp 0xe158
movq (%rsp), %r13
movq 0x2d8(%r13), %rbx
movq 0x2e0(%r13), %rdx
cmpq %rdx, %rbx
jb 0xe12c
movq 0x2d0(%r13), %rsi
cmpq %rdx, %rsi
ja 0xe721
subq %rsi, %rbx
subq %rsi, %rdx
movq %rdx, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %rdx
movl %eax, %r15d
pushq $0x1
popq %rax
cmoveq %rax, %r15
leaq (,%r15,4), %rcx
movq %r13, %rdi
callq 0x3e40
movq %rax, 0x2d0(%r13)
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %rbx
addq %rax, %rbx
movq %rbx, 0x2d8(%r13)
leaq (%rax,%r15,4), %rdx
movq %rdx, 0x2e0(%r13)
cmpq %rdx, %rbx
jae 0xe702
leaq 0x4(%rbx), %rax
movq (%rsp), %rcx
movq %rax, 0x2d8(%rcx)
movl %r12d, (%rbx)
movq 0x2b8(%rcx), %rax
movb $0x1, (%rax,%r12)
movq %rcx, %r12
incl %ebp
addq $0x8, %r14
jmp 0xdfca
leaq -0x4(%rax), %rcx
movq %rcx, 0x2d8(%r12)
movl -0x4(%rax), %eax
addq 0x2b8(%r12), %rax
cmpq 0x2c0(%r12), %rax
jae 0xe686
cmpb $0x0, (%rax)
je 0xe6a5
movb $0x0, (%rax)
movq 0x2d8(%r12), %rax
cmpq 0x2d0(%r12), %rax
ja 0xe161
cmpl $0x2000000, %ebp        # imm = 0x2000000
jae 0xe844
shll $0x5, %ebp
movq 0x8(%rsp), %rdi
movl 0x4(%rdi), %eax
movl $0xc000001f, %ecx       # imm = 0xC000001F
andl %ecx, %eax
orl %ebp, %eax
movl %eax, 0x4(%rdi)
movq 0x50(%rsp), %rax
cmpl $0x0, 0x14(%rsp)
jne 0xe1e8
jmp 0xe1e3
andl $0xc0000000, %esi       # imm = 0xC0000000
movq 0x8(%rsp), %rdi
movl %esi, 0x4(%rdi)
movq 0x48(%rsp), %rax
movq (%rax), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq %rdi, (%rcx)
movq 0x200(%r12), %rax
cmpq 0x1e0(%r12), %rax
je 0xe806
cmpl $0x0, 0x14(%rsp)
je 0xe2a0
movq 0x230(%r12), %r13
testq %r13, %r13
je 0xe2a0
cmpl $0x0, 0x238(%r12)
jne 0xe2a0
movl 0x23c(%r12), %edx
movl 0x240(%r12), %ecx
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
leaq 0x48a5(%rip), %rsi      # 0x12af2
xorl %eax, %eax
callq 0x11e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1090
movl $0xff, %ebx
subl %eax, %ebx
testl %ebx, %ebx
js 0xe281
pushq $0x20
popq %rdi
movq %r13, %rsi
callq 0x10f0
decl %ebx
jmp 0xe26e
pushq $0xa
popq %rdi
movq %r13, %rsi
callq 0x10f0
movq %r13, %rdi
callq 0x1170
movl $0x1, 0x238(%r12)
movq %r12, %rax
movq 0x8(%rsp), %rcx
leaq 0x18(%rcx), %r12
movq 0x258(%rax), %rdx
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r8d, %r8d
xorl %r14d, %r14d
movq %r12, 0x20(%rsp)
leaq (%rdx,%r13), %rax
movq (%rsp), %rcx
cmpq 0x260(%rcx), %rax
jae 0xe362
movq (%rax), %rbx
movq 0x8(%rsp), %rax
movq %rbx, 0x18(%rax,%r13)
cmpl $0x0, 0x14(%rsp)
je 0xe340
movq (%rsp), %rax
movq 0x230(%rax), %rdi
testq %rdi, %rdi
je 0xe340
movq (%rsp), %rax
movl 0x38(%rax), %eax
movl %ebx, %ecx
subl %eax, %ecx
movl %ecx, %eax
shrl %eax
movq %rdx, %r12
movl %eax, %edx
negl %edx
testb $0x1, %cl
cmovel %eax, %edx
leaq 0x39a9(%rip), %rsi      # 0x11cc8
xorl %eax, %eax
movl %r14d, %r15d
movq %rbp, %r14
movq %r8, %rbp
callq 0x1140
movq %r12, %rdx
movq 0x20(%rsp), %r12
movq %rbp, %r8
movq %r14, %rbp
movl %r15d, %r14d
movb (%rbx), %al
xorl %ecx, %ecx
cmpb $0x1, %al
sete %cl
adcl $0x0, %r8d
addl %ecx, %r14d
xorl %ecx, %ecx
cmpb $-0x1, %al
sete %cl
addl %ecx, %ebp
addq $0x8, %r13
jmp 0xe2c3
leal (%r8,%rbp), %eax
addl %r14d, %eax
cmpl 0x18(%rsp), %eax
jne 0xe76b
cmpl $0x0, 0x14(%rsp)
je 0xe39c
movq (%rsp), %rax
movq 0x230(%rax), %rsi
testq %rsi, %rsi
je 0xe39c
leaq 0x3941(%rip), %rdi      # 0x11cd2
movq %r8, %rbx
callq 0x10c0
movq %rbx, %r8
movq (%rsp), %rdi
movq 0x258(%rdi), %rax
movq %rax, 0x260(%rdi)
movq 0x18(%rsp), %rbx
testl %ebx, %ebx
setne %al
movl 0x44(%rsp), %ecx
andb %al, %cl
cmpb $0x1, %cl
jne 0xe3f1
movq 0x8(%rsp), %rdx
movq 0x18(%rdx), %rsi
movq %r8, %r15
callq 0xe996
movq %r15, %r8
cmpl $0x2, %ebx
jb 0xe418
movq 0x8(%rsp), %rdx
movq 0x20(%rdx), %rsi
movq (%rsp), %rdi
callq 0xe996
movq %r15, %r8
cmpl $0x2, %ebx
je 0xe421
testl %ebx, %ebx
jne 0xe418
movq (%rsp), %rax
cmpq $0x0, 0x248(%rax)
jne 0xe418
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x248(%rax)
movq 0x8(%rsp), %rax
orb $0x10, 0x4(%rax)
movq (%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0xe501
testl %ebp, %ebp
je 0xe501
movq (%rsp), %rdi
movq 0x260(%rdi), %rax
cmpq 0x258(%rdi), %rax
jne 0xe78a
movq 0x2a8(%rdi), %rax
cmpq 0x2a0(%rdi), %rax
jne 0xe7a9
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xd6e4
movl (%rbx), %eax
leaq (%r12,%rax,8), %rbx
pushq $0x1
popq %r14
cmpq %rbx, %r12
jae 0xe4ce
movq (%r12), %r13
movq (%rsp), %r15
movl 0x38(%r15), %eax
movl %r13d, %ebp
subl %eax, %ebp
shrl %ebp
shlq $0x4, %rbp
addq 0x40(%r15), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0xd69a
cmpb $-0x1, (%r13)
je 0xe4b9
movq %r15, %rdi
movq %r13, %rsi
callq 0x6ac0
jmp 0xe4c8
movq 0x8(%rbp), %rsi
movq %r15, %rdi
callq 0xd6e4
incl %r14d
addq $0x8, %r12
jmp 0xe47a
cmpl $0x1, %r14d
jbe 0xe7c8
xorl %eax, %eax
pushq $0x1
popq %rsi
movq 0x8(%rsp), %rcx
cmpq 0x28(%rsp), %rcx
movq (%rsp), %r12
jne 0xd83c
andl $0x0, 0xc0(%r12)
xorl %eax, %eax
jmp 0xd83c
movl %r8d, %eax
xorl $0x1, %eax
orl %r14d, %eax
jne 0xe5b6
movl 0x18(%rsp), %eax
leaq (%r12,%rax,8), %rbx
xorl %r14d, %r14d
movq %r12, %r15
cmpq %rbx, %r15
jae 0xe54f
movq (%r15), %rsi
cmpb $0x0, (%rsi)
cmoveq %rsi, %r14
movq (%rsp), %rdi
subl 0x38(%rdi), %esi
shrl %esi
shlq $0x4, %rsi
addq 0x40(%rdi), %rsi
movq %r8, %r13
callq 0xd69a
movq %r13, %r8
addq $0x8, %r15
jmp 0xe51e
testq %r14, %r14
je 0xe8c0
movq %r8, %rbx
movq 0x8(%rsp), %rdx
cmpl $0x2, 0x18(%rsp)
jne 0xe5a3
movq (%r12), %rax
cmpq %r14, %rax
movq 0x8(%rsp), %rcx
jne 0xe579
movq 0x20(%rcx), %rax
cmpb $-0x1, (%rax)
movq (%rsp), %rcx
jne 0xe8df
movq 0x38(%rcx), %rcx
subq %rcx, %rax
xorq $0x1, %rax
cmpb $0x1, (%rcx,%rax)
jne 0xe8fe
leaq 0x1(,%rax,2), %rdx
movq (%rsp), %rdi
movq %r14, %rsi
callq 0xd213
pushq $0x1
popq %r14
movq %rbx, %r8
cmpl 0x18(%rsp), %ebp
movq (%rsp), %rbx
movl 0x14(%rsp), %ebp
movq 0x8(%rsp), %r15
jne 0xe5fa
cmpq $0x0, 0x250(%rbx)
jne 0xe5fa
movq %r15, %rax
cmpq 0x28(%rsp), %r15
jne 0xe5f3
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %rbx, %rdi
movq %r8, %r12
callq 0xd586
movq %r12, %r8
movq %rax, 0x250(%rbx)
testl %ebp, %ebp
jne 0xe613
testl %r14d, %r14d
jne 0xe613
testl %r8d, %r8d
je 0xe613
movq %rbx, %rdi
movq %r15, %rsi
callq 0xeb83
cmpq 0x28(%rsp), %r15
jne 0xe621
andl $0x0, 0xc0(%rbx)
movq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42b0(%rip), %rdi      # 0x128ed
leaq 0x2c30(%rip), %rsi      # 0x11274
leaq 0x41dc(%rip), %rcx      # 0x12827
movl $0x942, %edx            # imm = 0x942
callq 0x10b0
leaq 0x4272(%rip), %rdi      # 0x128ce
leaq 0x2c11(%rip), %rsi      # 0x11274
leaq 0x41bd(%rip), %rcx      # 0x12827
movl $0x941, %edx            # imm = 0x941
callq 0x10b0
leaq 0x3dd1(%rip), %rdi      # 0x1244c
jmp 0xe6cb
leaq 0x43d4(%rip), %rdi      # 0x12a58
jmp 0xe6cb
leaq 0x42b7(%rip), %rdi      # 0x12944
leaq 0x2be0(%rip), %rsi      # 0x11274
leaq 0x418c(%rip), %rcx      # 0x12827
movl $0x956, %edx            # imm = 0x956
callq 0x10b0
leaq 0x42bf(%rip), %rdi      # 0x1296b
leaq 0x2bc1(%rip), %rsi      # 0x11274
leaq 0x416d(%rip), %rcx      # 0x12827
movl $0x957, %edx            # imm = 0x957
callq 0x10b0
leaq 0x3da0(%rip), %rdi      # 0x1246b
leaq 0x2ba2(%rip), %rsi      # 0x11274
leaq 0x4355(%rip), %rcx      # 0x12a2e
movl $0x680, %edx            # imm = 0x680
callq 0x10b0
leaq 0x41ce(%rip), %rdi      # 0x128b8
leaq 0x2b83(%rip), %rsi      # 0x11274
leaq 0x412f(%rip), %rcx      # 0x12827
movl $0x93d, %edx            # imm = 0x93D
callq 0x10b0
leaq 0x421f(%rip), %rdi      # 0x12928
leaq 0x2b64(%rip), %rsi      # 0x11274
leaq 0x4110(%rip), %rcx      # 0x12827
movl $0x949, %edx            # imm = 0x949
callq 0x10b0
leaq 0x41e3(%rip), %rdi      # 0x1290b
leaq 0x2b45(%rip), %rsi      # 0x11274
leaq 0x40f1(%rip), %rcx      # 0x12827
movl $0x948, %edx            # imm = 0x948
callq 0x10b0
leaq 0x40b4(%rip), %rdi      # 0x127fb
leaq 0x2b26(%rip), %rsi      # 0x11274
leaq 0x40d2(%rip), %rcx      # 0x12827
movl $0x8fd, %edx            # imm = 0x8FD
callq 0x10b0
leaq 0x3ccd(%rip), %rdi      # 0x12433
jmp 0xe6cb
leaq 0x4238(%rip), %rdi      # 0x129aa
leaq 0x2afb(%rip), %rsi      # 0x11274
leaq 0x40a7(%rip), %rcx      # 0x12827
movl $0x989, %edx            # imm = 0x989
callq 0x10b0
leaq 0x3fee(%rip), %rdi      # 0x1277f
leaq 0x2adc(%rip), %rsi      # 0x11274
leaq 0x4088(%rip), %rcx      # 0x12827
movl $0x9ad, %edx            # imm = 0x9AD
callq 0x10b0
leaq 0x3f85(%rip), %rdi      # 0x12735
leaq 0x2abd(%rip), %rsi      # 0x11274
leaq 0x4069(%rip), %rcx      # 0x12827
movl $0x9ae, %edx            # imm = 0x9AE
callq 0x10b0
leaq 0x4204(%rip), %rdi      # 0x129d3
leaq 0x2a9e(%rip), %rsi      # 0x11274
leaq 0x404a(%rip), %rcx      # 0x12827
movl $0x9c3, %edx            # imm = 0x9C3
callq 0x10b0
leaq 0x4097(%rip), %rdi      # 0x12885
leaq 0x2a7f(%rip), %rsi      # 0x11274
leaq 0x402b(%rip), %rcx      # 0x12827
movl $0x92d, %edx            # imm = 0x92D
callq 0x10b0
leaq 0x4183(%rip), %rdi      # 0x12990
leaq 0x2a60(%rip), %rsi      # 0x11274
leaq 0x400c(%rip), %rcx      # 0x12827
movl $0x96c, %edx            # imm = 0x96C
callq 0x10b0
leaq 0x4071(%rip), %rdi      # 0x1289d
leaq 0x2a41(%rip), %rsi      # 0x11274
leaq 0x3fed(%rip), %rcx      # 0x12827
movl $0x935, %edx            # imm = 0x935
callq 0x10b0
leaq 0x4135(%rip), %rdi      # 0x12980
leaq 0x2a22(%rip), %rsi      # 0x11274
leaq 0x3fce(%rip), %rcx      # 0x12827
movl $0x95c, %edx            # imm = 0x95C
callq 0x10b0
leaq 0x4247(%rip), %rdi      # 0x12ab1
leaq 0x2a03(%rip), %rsi      # 0x11274
leaq 0x4248(%rip), %rcx      # 0x12ac0
movl $0x534, %edx            # imm = 0x534
callq 0x10b0
leaq 0x3fc4(%rip), %rdi      # 0x1284d
leaq 0x29e4(%rip), %rsi      # 0x11274
leaq 0x3f90(%rip), %rcx      # 0x12827
movl $0x90b, %edx            # imm = 0x90B
callq 0x10b0
leaq 0x3fc1(%rip), %rdi      # 0x12869
leaq 0x29c5(%rip), %rsi      # 0x11274
leaq 0x3f71(%rip), %rcx      # 0x12827
movl $0x923, %edx            # imm = 0x923
callq 0x10b0
leaq 0x428d(%rip), %rdi      # 0x12b54
leaq 0x29a6(%rip), %rsi      # 0x11274
leaq 0x3f52(%rip), %rcx      # 0x12827
movl $0x9d9, %edx            # imm = 0x9D9
callq 0x10b0
leaq 0x4101(%rip), %rdi      # 0x129e7
leaq 0x2987(%rip), %rsi      # 0x11274
leaq 0x3f33(%rip), %rcx      # 0x12827
movl $0x9e3, %edx            # imm = 0x9E3
callq 0x10b0
leaq 0x40f6(%rip), %rdi      # 0x129fb
leaq 0x2968(%rip), %rsi      # 0x11274
leaq 0x3f14(%rip), %rcx      # 0x12827
movl $0x9e4, %edx            # imm = 0x9E4
callq 0x10b0