// File: /workspace/github_cpp_makefile_star2_O3/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 $0xd8, %rsp
movq %rdi, %rbx
leaq 0x200(%rdi), %rax
movq %rax, 0x50(%rsp)
leaq 0x1e8(%rdi), %rax
movq %rax, 0x58(%rsp)
leaq 0x70(%rdi), %rax
movq %rax, 0x30(%rsp)
movb $0x1, %al
movl %eax, 0x4c(%rsp)
movl %esi, 0x14(%rsp)
movq 0x258(%rbx), %r13
movq 0x260(%rbx), %rcx
subq %r13, %rcx
shrq $0x3, %rcx
movq 0x2a0(%rbx), %rax
movq %rax, 0x2a8(%rbx)
testl %esi, %esi
je 0xec0b
incl 0x43c(%rbx)
addl %ecx, 0x450(%rbx)
cmpl $0x3, %ecx
jb 0xec28
incl 0x444(%rbx)
incl 0x42c(%rbx)
addl %ecx, 0x434(%rbx)
jmp 0xec28
incl 0x438(%rbx)
cmpl $0x3, %ecx
jb 0xec28
incl 0x440(%rbx)
incl 0x428(%rbx)
addl %ecx, 0x430(%rbx)
movq %rcx, 0x8(%rsp)
movl 0x438(%rbx), %eax
movl 0x448(%rbx), %ecx
incl %ecx
movl %ecx, 0x448(%rbx)
addl 0x43c(%rbx), %eax
cmpl %eax, %ecx
jne 0x1010e
movq 0x8(%rsp), %rcx
cmpl $0x2, %ecx
jne 0xec6e
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0xeac3
jmp 0xfa43
movq 0x478(%rbx), %rax
cmpq 0x470(%rbx), %rax
jne 0x1012d
leal -0x1(%rcx), %edx
movq %rdx, 0x40(%rsp)
movq %rcx, %rdx
movq %rax, %rcx
cmpl $0xc, %edx
jl 0xf2e5
leaq 0x8(%r13), %rax
movq %rax, 0x70(%rsp)
xorl %r14d, %r14d
movq 0x40(%rsp), %rax
movl %eax, %ebp
movq %r13, 0x28(%rsp)
leal (%r14,%rbp), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ebp, %rdx
movq -0x8(%r13,%rdx,8), %rax
movslq %ecx, %rcx
movq (%r13,%rcx,8), %rsi
movq %rsi, -0x8(%r13,%rdx,8)
movq %rax, (%r13,%rcx,8)
movslq %r14d, %r10
movq (%r13,%r10,8), %rax
movq -0x8(%r13,%rdx,8), %rdi
movb (%rax), %cl
movb (%rdi), %r8b
testb %cl, %cl
movq %r14, 0x20(%rsp)
jne 0xed03
testb %r8b, %r8b
je 0xed03
xorl %r8d, %r8d
movq %rax, %rdi
jmp 0xeda9
testb %cl, %cl
je 0xed10
testb %r8b, %r8b
je 0xed9f
movl 0x38(%rbx), %r11d
movl %eax, %r9d
subl %r11d, %r9d
shlq $0x3, %r9
movabsq $0x7fffffff0, %r14      # imm = 0x7FFFFFFF0
andq %r14, %r9
movl %edi, %esi
subl %r11d, %esi
shlq $0x3, %rsi
andq %r14, %rsi
testb %cl, %cl
je 0xed54
testb %r8b, %r8b
je 0xff88
movq 0x40(%rbx), %r14
movl 0x4(%r14,%rsi), %r11d
subl 0x4(%r14,%r9), %r11d
jne 0xed91
movq 0x48(%rbx), %r14
movq %r9, %r11
shrq %r11
movq %rbp, %r12
movl (%r14,%r11), %ebp
movq %rsi, %r15
shrq %r15
xorl %r11d, %r11d
cmpl (%r14,%r15), %ebp
seta %r11b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmovbl %ebp, %r11d
movq %r12, %rbp
testl %r11d, %r11d
jne 0xed91
subq %rsi, %r9
shrq $0x4, %r9
movl %r9d, %r11d
testl %r11d, %r11d
movq 0x20(%rsp), %r14
jle 0xf2d1
movq %rax, -0x8(%r13,%rdx,8)
movq %rdi, (%r13,%r10,8)
movq (%r13,%rdx,8), %rsi
movb (%rsi), %cl
testb %r8b, %r8b
jne 0xedbd
testb %cl, %cl
jne 0xee68
testb %r8b, %r8b
je 0xedca
testb %cl, %cl
je 0xee57
movq %r14, %r12
movl 0x38(%rbx), %r11d
movl %edi, %r9d
subl %r11d, %r9d
shlq $0x3, %r9
movabsq $0x7fffffff0, %r14      # imm = 0x7FFFFFFF0
andq %r14, %r9
movl %esi, %eax
subl %r11d, %eax
shlq $0x3, %rax
andq %r14, %rax
testb %r8b, %r8b
je 0xee11
testb %cl, %cl
je 0xff88
movq 0x40(%rbx), %r11
movl 0x4(%r11,%rax), %r8d
subl 0x4(%r11,%r9), %r8d
jne 0xee4f
movq 0x48(%rbx), %r11
movq %r9, %r8
shrq %r8
movq %rbp, %r15
movl (%r11,%r8), %ebp
movq %rax, %r14
shrq %r14
xorl %r8d, %r8d
cmpl (%r11,%r14), %ebp
movq %r15, %rbp
seta %r8b
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmovbl %r11d, %r8d
testl %r8d, %r8d
jne 0xee4f
subq %rax, %r9
shrq $0x4, %r9
movl %r9d, %r8d
testl %r8d, %r8d
movq %r12, %r14
jle 0xee68
movq %rdi, (%r13,%rdx,8)
movq %rsi, (%r13,%r10,8)
movq (%r13,%rdx,8), %rsi
movb (%rsi), %cl
movq -0x8(%r13,%rdx,8), %rax
movb (%rax), %dil
testb %dil, %dil
jne 0xee83
testb %cl, %cl
je 0xee83
xorl %ecx, %ecx
movq %rax, %rsi
jmp 0xef2c
testb %dil, %dil
je 0xee90
testb %cl, %cl
je 0xef22
movl 0x38(%rbx), %r10d
movl %eax, %r8d
subl %r10d, %r8d
shlq $0x3, %r8
movabsq $0x7fffffff0, %r11      # imm = 0x7FFFFFFF0
andq %r11, %r8
movl %esi, %r9d
subl %r10d, %r9d
shlq $0x3, %r9
andq %r11, %r9
testb %dil, %dil
je 0xeed5
testb %cl, %cl
je 0xff88
movq 0x40(%rbx), %r11
movl 0x4(%r11,%r9), %r10d
subl 0x4(%r11,%r8), %r10d
jne 0xef19
movq 0x48(%rbx), %r11
movq %r8, %r10
shrq %r10
movq %rbp, %r15
movl (%r11,%r10), %ebp
movq %r14, %r12
movq %r9, %r14
shrq %r14
xorl %r10d, %r10d
cmpl (%r11,%r14), %ebp
movq %r12, %r14
movq %r15, %rbp
seta %r10b
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmovbl %r11d, %r10d
testl %r10d, %r10d
jne 0xef19
subq %r9, %r8
shrq $0x4, %r8
movl %r8d, %r10d
testl %r10d, %r10d
jle 0xf2d9
movq %rax, (%r13,%rdx,8)
movq %rsi, -0x8(%r13,%rdx,8)
movq %rbp, 0x68(%rsp)
leal -0x1(%rbp), %r10d
movslq %r10d, %rax
movq %rax, 0x60(%rsp)
leal 0x2(%r14), %eax
movslq %eax, %r9
negq %r9
movq %r14, 0x78(%rsp)
movslq %r14d, %r12
movq 0x70(%rsp), %rax
leaq (%rax,%r12,8), %rdx
xorl %eax, %eax
movq %rax, %rdi
movq (%rdx,%rax,8), %r11
movb (%r11), %bpl
testb %bpl, %bpl
jne 0xef77
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0xf004
testb %bpl, %bpl
je 0xef84
testb %cl, %cl
je 0xf011
movl 0x38(%rbx), %r14d
movl %r11d, %r8d
subl %r14d, %r8d
shlq $0x3, %r8
movabsq $0x7fffffff0, %r15      # imm = 0x7FFFFFFF0
andq %r15, %r8
movl %esi, %eax
subl %r14d, %eax
shlq $0x3, %rax
andq %r15, %rax
testb %bpl, %bpl
je 0xefc8
testb %cl, %cl
je 0xff88
movq 0x40(%rbx), %r15
movl 0x4(%r15,%rax), %r14d
subl 0x4(%r15,%r8), %r14d
jne 0xf004
movq 0x48(%rbx), %r15
movq %r8, %r14
shrq %r14
movl (%r15,%r14), %ebp
movq %rax, %r13
shrq %r13
xorl %r14d, %r14d
cmpl (%r15,%r13), %ebp
movq 0x28(%rsp), %r13
seta %r14b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmovbl %ebp, %r14d
testl %r14d, %r14d
jne 0xf004
subq %rax, %r8
shrq $0x4, %r8
movl %r8d, %r14d
leaq 0x1(%rdi), %rax
testl %r14d, %r14d
js 0xef5a
movl %r12d, %eax
addq %rdi, %rax
incq %rax
movq %rax, 0x18(%rsp)
movslq %r10d, %rax
leaq (%r12,%rdi), %r8
incq %r8
movq %r8, 0x38(%rsp)
decq %rax
movq %rax, %r10
movq (%r13,%rax,8), %rbp
movb (%rbp), %r14b
testb %cl, %cl
jne 0xf050
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb %r14b, %r14b
jne 0xf0de
testb %cl, %cl
je 0xf05d
testb %r14b, %r14b
je 0xf0f5
movl 0x38(%rbx), %r15d
movl %esi, %eax
subl %r15d, %eax
shlq $0x3, %rax
movabsq $0x7fffffff0, %r12      # imm = 0x7FFFFFFF0
andq %r12, %rax
movl %ebp, %r8d
subl %r15d, %r8d
shlq $0x3, %r8
andq %r12, %r8
testb %cl, %cl
je 0xf0a1
testb %r14b, %r14b
je 0xff88
movq 0x40(%rbx), %r14
movl 0x4(%r14,%r8), %r15d
subl 0x4(%r14,%rax), %r15d
jne 0xf0de
movq 0x48(%rbx), %r14
movq %rax, %r15
shrq %r15
movl (%r14,%r15), %r13d
movq %r8, %r12
shrq %r12
xorl %r15d, %r15d
cmpl (%r14,%r12), %r13d
movq 0x28(%rsp), %r13
seta %r15b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmovbl %r14d, %r15d
testl %r15d, %r15d
jne 0xf0de
subq %r8, %rax
shrq $0x4, %rax
movl %eax, %r15d
leaq (%r9,%r10), %rax
cmpq $-0x1, %rax
je 0xf0f5
leaq -0x1(%r10), %rax
testl %r15d, %r15d
js 0xf031
cmpq %r10, 0x38(%rsp)
jge 0xf10f
movq %r11, (%r13,%r10,8)
movq %rbp, (%rdx,%rdi,8)
movq 0x18(%rsp), %r14
jmp 0xef47
movq 0x78(%rsp), %r9
leal (%r9,%rdi), %eax
movq 0x60(%rsp), %rsi
movq (%r13,%rsi,8), %rcx
movq %r11, (%r13,%rsi,8)
movl %eax, %esi
movq 0x20(%rsp), %r14
subl %r14d, %esi
incl %esi
movl %r9d, %r8d
notl %r8d
movq 0x68(%rsp), %rbp
addl %ebp, %r8d
subl %edi, %r8d
cmpl %r8d, %esi
leal 0x2(%r9,%rdi), %esi
movl %eax, %r8d
cmovll %ebp, %r8d
movl %r14d, %r15d
cmovll %esi, %r15d
cmovll %eax, %ebp
movq %rcx, (%rdx,%rdi,8)
cmovgel %esi, %r14d
movl %ebp, %ecx
subl %r14d, %ecx
movl %r8d, %eax
subl %r15d, %eax
cmpl $0xb, %ecx
jl 0xf298
cmpl $0xa, %eax
jle 0xffee
movq 0x478(%rbx), %r12
movq 0x480(%rbx), %rdx
cmpq %rdx, %r12
jne 0xf203
movq 0x470(%rbx), %rsi
cmpq %r12, %rsi
ja 0x10016
subq %rsi, %r12
movq %r12, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %r12
movq %r14, 0x20(%rsp)
movl %eax, %r14d
movl $0x1, %eax
cmoveq %rax, %r14
leaq (,%r14,4), %rcx
movq %rbx, %rdi
movq %r12, %rdx
movl %r8d, 0x38(%rsp)
callq 0x473a
movl 0x38(%rsp), %r8d
movq %rax, 0x470(%rbx)
addq %rax, %r12
leaq (%rax,%r14,4), %rdx
movq 0x20(%rsp), %r14
movq %rdx, 0x480(%rbx)
leaq 0x4(%r12), %rax
movq %rax, 0x478(%rbx)
movl %r15d, (%r12)
cmpq %rdx, %rax
jne 0xf285
movq 0x470(%rbx), %rsi
cmpq %rdx, %rsi
ja 0x10016
subq %rsi, %rdx
movq %rdx, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %rdx
movq %r14, 0x20(%rsp)
movl %eax, %r14d
movl $0x1, %eax
cmoveq %rax, %r14
leaq (,%r14,4), %rcx
movq %rbx, %rdi
movq %rdx, %r15
movl %r8d, %r12d
callq 0x473a
movl %r12d, %r8d
movq %rax, 0x470(%rbx)
addq %rax, %r15
leaq (%rax,%r14,4), %rax
movq 0x20(%rsp), %r14
movq %rax, 0x480(%rbx)
movq %r15, %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x478(%rbx)
movl %r8d, (%rax)
jmp 0xecb1
movl %r8d, %ebp
movl %r15d, %r14d
cmpl $0xa, %eax
jg 0xecb1
movq 0x470(%rbx), %rax
movq 0x478(%rbx), %rcx
cmpq %rax, %rcx
jbe 0xf2e0
movl -0x4(%rcx), %ebp
leaq -0x8(%rcx), %rax
movq %rax, 0x478(%rbx)
movl -0x8(%rcx), %r14d
jmp 0xecb1
movl %ecx, %r8d
jmp 0xecfb
movl %edi, %ecx
jmp 0xee7b
movq 0x8(%rsp), %rdx
cmpl $0x2, %edx
jl 0xf4a7
movl 0x40(%rsp), %eax
incq %rax
movq -0x10(%r13,%rax,8), %rcx
movq -0x8(%r13,%rax,8), %rdx
movb (%rcx), %r9b
movb (%rdx), %r8b
testb %r9b, %r9b
jne 0xf313
testb %r8b, %r8b
jne 0xf3ac
testb %r9b, %r9b
je 0xf321
testb %r8b, %r8b
je 0xf3a2
movl 0x38(%rbx), %r10d
movl %ecx, %esi
subl %r10d, %esi
shlq $0x3, %rsi
movabsq $0x7fffffff0, %r11      # imm = 0x7FFFFFFF0
andq %r11, %rsi
movl %edx, %edi
subl %r10d, %edi
shlq $0x3, %rdi
andq %r11, %rdi
testb %r9b, %r9b
je 0xf365
testb %r8b, %r8b
je 0xff88
movq 0x40(%rbx), %r9
movl 0x4(%r9,%rdi), %r8d
subl 0x4(%r9,%rsi), %r8d
jne 0xf39d
movq 0x48(%rbx), %r9
movq %rsi, %r8
shrq %r8
movl (%r9,%r8), %r10d
movq %rdi, %r11
shrq %r11
xorl %r8d, %r8d
cmpl (%r9,%r11), %r10d
seta %r8b
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
cmovbl %r9d, %r8d
testl %r8d, %r8d
jne 0xf39d
subq %rdi, %rsi
shrq $0x4, %rsi
movl %esi, %r8d
testl %r8d, %r8d
jle 0xf3ac
movq %rcx, -0x8(%r13,%rax,8)
movq %rdx, -0x10(%r13,%rax,8)
decq %rax
cmpq $0x1, %rax
jg 0xf2f5
movq 0x8(%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0x10(%r13), %rcx
movl $0x2, %edx
movq (%r13,%rdx,8), %rsi
movb (%rsi), %r8b
movq %rcx, %rdi
movq -0x8(%rdi), %r9
movb (%r9), %bpl
testb %r8b, %r8b
jne 0xf3ec
testb %bpl, %bpl
jne 0xf47a
testb %r8b, %r8b
je 0xf3fa
testb %bpl, %bpl
je 0xf486
movl 0x38(%rbx), %r14d
movl %esi, %r10d
subl %r14d, %r10d
shlq $0x3, %r10
movabsq $0x7fffffff0, %r15      # imm = 0x7FFFFFFF0
andq %r15, %r10
movl %r9d, %r11d
subl %r14d, %r11d
shlq $0x3, %r11
andq %r15, %r11
testb %r8b, %r8b
je 0xf440
testb %bpl, %bpl
je 0xff88
movq 0x40(%rbx), %r14
movl 0x4(%r14,%r11), %ebp
subl 0x4(%r14,%r10), %ebp
jne 0xf476
movq 0x48(%rbx), %r14
movq %r10, %r15
shrq %r15
movl (%r14,%r15), %r15d
movq %r11, %r12
shrq %r12
xorl %ebp, %ebp
cmpl (%r14,%r12), %r15d
seta %bpl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmovbl %r14d, %ebp
testl %ebp, %ebp
jne 0xf476
subq %r11, %r10
shrq $0x4, %r10
movl %r10d, %ebp
testl %ebp, %ebp
jns 0xf486
movq %r9, (%rdi)
addq $-0x8, %rdi
jmp 0xf3d7
movq %rsi, (%rdi)
incq %rdx
addq $0x8, %rcx
cmpq %rax, %rdx
jne 0xf3cc
movq 0x470(%rbx), %rax
movq 0x478(%rbx), %rcx
cmpq %rax, %rcx
jne 0x1012d
movq 0x40(%rsp), %r10
testl %r10d, %r10d
movl $0x0, %eax
cmovlel %eax, %r10d
shlq $0x3, %r10
xorl %eax, %eax
cmpq %rax, %r10
je 0xf58a
movq (%r13,%rax), %rcx
movq 0x8(%r13,%rax), %rdx
movb (%rcx), %dil
movb (%rdx), %sil
testb %dil, %dil
jne 0xf4f4
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testb %sil, %sil
jne 0xf578
testb %dil, %dil
je 0xf502
testb %sil, %sil
je 0xffe5
movl 0x38(%rbx), %r8d
subl %r8d, %ecx
shlq $0x3, %rcx
movabsq $0x7fffffff0, %r9       # imm = 0x7FFFFFFF0
andq %r9, %rcx
subl %r8d, %edx
shlq $0x3, %rdx
andq %r9, %rdx
testb %dil, %dil
je 0xf542
testb %sil, %sil
je 0xff88
movq 0x40(%rbx), %rsi
movl 0x4(%rsi,%rdx), %r8d
subl 0x4(%rsi,%rcx), %r8d
jne 0xf578
movq 0x48(%rbx), %rsi
movq %rcx, %rdi
shrq %rdi
movl (%rsi,%rdi), %edi
movq %rdx, %r9
shrq %r9
xorl %r8d, %r8d
cmpl (%rsi,%r9), %edi
seta %r8b
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmovbl %esi, %r8d
testl %r8d, %r8d
jne 0xf578
subq %rdx, %rcx
shrq $0x4, %rcx
movl %ecx, %r8d
addq $0x8, %rax
testl %r8d, %r8d
jle 0xf4c7
jmp 0xffe5
cmpl $0x0, 0x14(%rsp)
je 0xf67e
movq 0x200(%rbx), %rax
cmpq 0x208(%rbx), %rax
movq 0x8(%rsp), %rcx
jne 0xf75e
movq 0x1f8(%rbx), %rsi
cmpq %rax, %rsi
ja 0x10250
subq %rsi, %rax
movq %rax, %r12
shrq $0x3, %r12
movabsq $0x7fffffff0, %rcx      # imm = 0x7FFFFFFF0
leaq 0x8(%rcx), %rdx
movq %rax, %rcx
shrq $0x2, %rcx
andq %rax, %rdx
movl %ecx, %r14d
movl $0x1, %eax
cmoveq %rax, %r14
leaq (,%r14,8), %r15
movq %rbx, %rdi
movq %r15, %rcx
callq 0x473a
movq %rax, 0x1f8(%rbx)
movl %r12d, %r12d
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x200(%rbx)
leaq (%rax,%r14,8), %rcx
movq %rcx, 0x208(%rbx)
cmpq 0x1e0(%rbx), %rcx
movq 0x8(%rsp), %rcx
jne 0xf75e
leal (%r14,%r14), %r13d
testq %r14, %r14
movl $0x1, %ecx
cmoveq %rcx, %r13
leaq (,%r13,8), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x473a
movq %rax, 0x1f8(%rbx)
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x200(%rbx)
movq 0x8(%rsp), %rcx
leaq (%rax,%r13,8), %rax
movq %rax, 0x208(%rbx)
jmp 0xf75e
movq 0x1e8(%rbx), %rax
cmpq 0x1f0(%rbx), %rax
movq 0x8(%rsp), %rcx
jne 0xf75e
movq 0x1e0(%rbx), %rsi
cmpq %rax, %rsi
ja 0x1026f
subq %rsi, %rax
movq %rax, %r12
shrq $0x3, %r12
movabsq $0x7fffffff0, %rcx      # imm = 0x7FFFFFFF0
leaq 0x8(%rcx), %rdx
movq %rax, %rcx
shrq $0x2, %rcx
andq %rax, %rdx
movl %ecx, %r14d
movl $0x1, %eax
cmoveq %rax, %r14
leaq (,%r14,8), %r15
movq %rbx, %rdi
movq %r15, %rcx
callq 0x473a
movq %rax, 0x1e0(%rbx)
movl %r12d, %r12d
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x1e8(%rbx)
leaq (%rax,%r14,8), %rcx
movq %rcx, 0x1f0(%rbx)
cmpq %rax, 0x208(%rbx)
movq 0x8(%rsp), %rcx
jne 0xf75e
leal (%r14,%r14), %r13d
testq %r14, %r14
movl $0x1, %ecx
cmoveq %rcx, %r13
leaq (,%r13,8), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x473a
movq %rax, 0x1e0(%rbx)
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x1e8(%rbx)
movq 0x8(%rsp), %rcx
leaq (%rax,%r13,8), %rax
movq %rax, 0x1f0(%rbx)
movq 0x208(%rbx), %rax
cmpq 0x1e0(%rbx), %rax
je 0x101b5
movl %ecx, %r15d
movl 0x14(%rsp), %ebp
testl %ebp, %ebp
setne %al
cmpl $0x3, %ecx
movq %rcx, %r12
setae %cl
andb %al, %cl
movzbl %cl, %r14d
leal (,%r14,4), %eax
leaq (%rax,%r15,8), %rsi
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x9cfe
movl %r12d, (%rax)
movl 0x4(%rax), %esi
movl %ebp, %ecx
andl $0x1, %ecx
movl %esi, %edx
andl $-0x20, %edx
leal (%rdx,%rcx,2), %ecx
movq %rax, 0x18(%rsp)
movl %ecx, 0x4(%rax)
cmpb $0x1, %r14b
jne 0xf7e2
testb $0x1, %bpl
je 0x10212
movl 0x310(%rbx), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax,%r15,8)
jmp 0xf7ef
testl %ebp, %ebp
movq 0x18(%rsp), %rax
je 0xfa14
movq 0x2d8(%rbx), %rcx
cmpq 0x2d0(%rbx), %rcx
jne 0x101f3
movq 0x258(%rbx), %rbp
cmpq 0x260(%rbx), %rbp
jae 0xfa06
xorl %r14d, %r14d
movq (%rbp), %rax
cmpb $0x0, (%rax)
je 0xf97e
movq 0x40(%rbx), %rcx
subl 0x38(%rbx), %eax
shrl %eax
shlq $0x4, %rax
movl 0x4(%rcx,%rax), %r12d
cmpl 0x28(%rbx), %r12d
ja 0x10054
movq 0x2b8(%rbx), %rsi
movq 0x2c0(%rbx), %r13
leaq (%rsi,%r12), %rax
cmpq %r13, %rax
jb 0xf8d1
movq 0x2c8(%rbx), %rdx
cmpq %rdx, %r13
jb 0xf8b3
cmpq %rdx, %rsi
ja 0xffc6
subl %esi, %r13d
subq %rsi, %rdx
leal (%rdx,%rdx), %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
andq %rax, %rdx
movl $0x1, %eax
cmoveq %rax, %r15
movq %rbx, %rdi
movq %r15, %rcx
callq 0x473a
movq %rax, 0x2b8(%rbx)
addq %rax, %r13
movq %r13, 0x2c0(%rbx)
addq %rax, %r15
movq %r15, 0x2c8(%rbx)
movq %r15, %rdx
cmpq %rdx, %r13
jae 0xffa7
leaq 0x1(%r13), %rax
movq %rax, 0x2c0(%rbx)
movb $0x0, (%r13)
jmp 0xf843
cmpb $0x0, (%rax)
jne 0xf981
movq 0x2d8(%rbx), %r15
movq 0x2e0(%rbx), %rdx
cmpq %rdx, %r15
jb 0xf95b
movq 0x2d0(%rbx), %rsi
cmpq %rdx, %rsi
ja 0x10196
subq %rsi, %r15
subq %rsi, %rdx
movq %rdx, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %rdx
movl %eax, %r13d
movl $0x1, %eax
cmoveq %rax, %r13
leaq (,%r13,4), %rcx
movq %rbx, %rdi
callq 0x473a
movq %rax, 0x2d0(%rbx)
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %r15
addq %rax, %r15
movq %r15, 0x2d8(%rbx)
leaq (%rax,%r13,4), %rdx
movq %rdx, 0x2e0(%rbx)
cmpq %rdx, %r15
jae 0x100ef
leaq 0x4(%r15), %rax
movq %rax, 0x2d8(%rbx)
movl %r12d, (%r15)
movq 0x2b8(%rbx), %rax
movb $0x1, (%rax,%r12)
incl %r14d
addq $0x8, %rbp
cmpq 0x260(%rbx), %rbp
jb 0xf81a
jmp 0xf9c2
leaq -0x4(%rax), %rcx
movq %rcx, 0x2d8(%rbx)
movl -0x4(%rax), %eax
addq 0x2b8(%rbx), %rax
cmpq 0x2c0(%rbx), %rax
jae 0x10092
cmpb $0x0, (%rax)
je 0x10073
movb $0x0, (%rax)
movq 0x2d8(%rbx), %rax
cmpq 0x2d0(%rbx), %rax
ja 0xf994
cmpl $0x2000000, %r14d       # imm = 0x2000000
jae 0x10231
shll $0x5, %r14d
movq 0x18(%rsp), %rax
movl 0x4(%rax), %edx
movl $0xc000001f, %ecx       # imm = 0xC000001F
andl %ecx, %edx
orl %r14d, %edx
movl %edx, 0x4(%rax)
movq 0x50(%rsp), %rsi
cmpl $0x0, 0x14(%rsp)
jne 0xfa22
jmp 0xfa1d
andl $0xc000001f, 0x4(%rax)  # imm = 0xC000001F
movq 0x50(%rsp), %rsi
jmp 0xfa22
andl $0xc0000000, %esi       # imm = 0xC0000000
movl %esi, 0x4(%rax)
movq 0x58(%rsp), %rsi
movq (%rsi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%rsi)
movq %rax, (%rcx)
movq 0x200(%rbx), %rcx
cmpq 0x1e0(%rbx), %rcx
je 0x101d4
cmpl $0x0, 0x14(%rsp)
movq %rax, 0x18(%rsp)
je 0xfaf2
movq 0x230(%rbx), %r15
testq %r15, %r15
je 0xfaf2
cmpl $0x0, 0x238(%rbx)
jne 0xfaf2
movl 0x23c(%rbx), %edx
movl 0x240(%rbx), %ecx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
leaq 0x506c(%rip), %rsi      # 0x14afa
xorl %eax, %eax
callq 0x11e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x10c0
movq %r14, %rdi
callq 0x1090
movq %rax, %r13
movl $0xff, %eax
cmpl %r13d, %eax
js 0xface
addl $0xffffff00, %r13d      # imm = 0xFFFFFF00
movl $0x20, %edi
movq %r15, %rsi
callq 0x10f0
incl %r13d
jne 0xfabc
movl $0xa, %edi
movq %r15, %rsi
callq 0x10f0
movq %r15, %rdi
callq 0x1170
movl $0x1, 0x238(%rbx)
movq 0x18(%rsp), %rax
leaq 0x18(%rax), %r13
movq 0x258(%rbx), %r12
xorl %r8d, %r8d
movl $0x0, %ebp
movl $0x0, %r9d
cmpq 0x260(%rbx), %r12
jae 0xfbaa
xorl %r9d, %r9d
xorl %ebp, %ebp
xorl %r8d, %r8d
movq %r13, %r15
movq (%r12), %r14
movq %r14, (%r15)
cmpl $0x0, 0x14(%rsp)
je 0xfb7b
movq 0x230(%rbx), %rdi
testq %rdi, %rdi
je 0xfb7b
movl 0x38(%rbx), %eax
movl %r14d, %ecx
subl %eax, %ecx
movl %ecx, %eax
shrl %eax
movl %eax, %edx
negl %edx
testb $0x1, %cl
cmovel %eax, %edx
leaq 0x4176(%rip), %rsi      # 0x13cd0
xorl %eax, %eax
movq %rbp, 0x28(%rsp)
movq %r8, 0x38(%rsp)
movl %r9d, %ebp
callq 0x1140
movl %ebp, %r9d
movq 0x38(%rsp), %r8
movq 0x28(%rsp), %rbp
addq $0x8, %r15
movb (%r14), %al
xorl %ecx, %ecx
cmpb $0x1, %al
sete %cl
adcl $0x0, %ebp
addl %ecx, %r9d
xorl %ecx, %ecx
cmpb $-0x1, %al
sete %cl
addl %ecx, %r8d
addq $0x8, %r12
cmpq 0x260(%rbx), %r12
jb 0xfb23
leal (%r8,%rbp), %eax
addl %r9d, %eax
movq 0x8(%rsp), %rcx
cmpl %ecx, %eax
jne 0x10139
cmpl $0x0, 0x14(%rsp)
movq %r8, %r15
je 0xfbee
movq 0x230(%rbx), %rsi
testq %rsi, %rsi
je 0xfbee
leaq 0x40ff(%rip), %rdi      # 0x13cda
movl %r9d, %r14d
callq 0x10c0
movl %r14d, %r9d
movq %r15, %r8
movq 0x8(%rsp), %rcx
movq 0x258(%rbx), %rax
movq %rax, 0x260(%rbx)
testl %ecx, %ecx
setne %al
movl 0x4c(%rsp), %edx
andb %al, %dl
cmpb $0x1, %dl
movq 0x18(%rsp), %r14
jne 0xfc4d
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %r9d, %r12d
callq 0x10367
movl %r12d, %r9d
movq %r15, %r8
movq 0x8(%rsp), %rcx
cmpl $0x2, %ecx
jb 0xfc67
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10367
movl %r12d, %r9d
movq %r15, %r8
movq 0x8(%rsp), %rcx
cmpl $0x2, %ecx
je 0xfc6c
testl %ecx, %ecx
jne 0xfc67
cmpq $0x0, 0x248(%rbx)
jne 0xfc67
movq %r14, 0x248(%rbx)
orb $0x10, 0x4(%r14)
cmpl $0x0, 0x28(%rbx)
jne 0xfe58
testl %r8d, %r8d
je 0xfe58
movq 0x260(%rbx), %rax
cmpq 0x258(%rbx), %rax
jne 0x10158
movq 0x2a0(%rbx), %rsi
movq 0x2a8(%rbx), %rax
cmpq %rsi, %rax
jne 0x10177
cmpq %r14, 0x30(%rsp)
sete %cl
orb %r14b, %cl
testb $0x1, %cl
jne 0xfcfc
cmpq 0x2b0(%rbx), %rax
je 0xfcca
jb 0xfcee
jmp 0x10035
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x473a
movq %rax, 0x2a0(%rbx)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x2b0(%rbx)
leaq 0x8(%rax), %rcx
movq %rcx, 0x2a8(%rbx)
movq %r14, (%rax)
movl (%r14), %eax
testq %rax, %rax
je 0x100d0
leaq (%r14,%rax,8), %r15
addq $0x18, %r15
movl $0x1, %ebp
movq (%r13), %rsi
movq 0x40(%rbx), %rcx
movl 0x38(%rbx), %eax
movl %esi, %edx
subl %eax, %edx
shrl %edx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movzwl (%rcx,%rdx), %ecx
testb $0x10, %cl
jne 0xfd43
orl $0x10, %ecx
movw %cx, (%rax)
incl 0x44c(%rbx)
cmpb $-0x1, (%rsi)
je 0xfd55
movq %rbx, %rdi
callq 0x7585
jmp 0xfe1f
movq 0x8(%rax), %r12
testq %r12, %r12
je 0xfff7
cmpq %r12, 0x30(%rsp)
sete %al
orb %r12b, %al
testb $0x1, %al
jne 0xfe1d
movl %ebp, 0x28(%rsp)
movq 0x2a8(%rbx), %rbp
movq 0x2b0(%rbx), %rax
cmpq %rax, %rbp
jne 0xfe01
movq 0x2a0(%rbx), %rsi
cmpq %rbp, %rsi
ja 0x100b1
subq %rsi, %rbp
movabsq $0x7fffffff0, %rax      # imm = 0x7FFFFFFF0
leaq 0x8(%rax), %rdx
movq %rbp, %rax
shrq $0x2, %rax
andq %rbp, %rdx
movl %eax, %r14d
movl $0x1, %eax
cmoveq %rax, %r14
leaq (,%r14,8), %rcx
movq %rbx, %rdi
callq 0x473a
movq %rax, 0x2a0(%rbx)
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
andq %rcx, %rbp
addq %rax, %rbp
movq %rbp, 0x2a8(%rbx)
leaq (%rax,%r14,8), %rax
movq %rax, 0x2b0(%rbx)
movq 0x18(%rsp), %r14
cmpq %rax, %rbp
jae 0x10035
leaq 0x8(%rbp), %rax
movq %rax, 0x2a8(%rbx)
movq %r12, (%rbp)
movl 0x28(%rsp), %ebp
incl %ebp
addq $0x8, %r13
cmpq %r15, %r13
jb 0xfd15
cmpl $0x1, %ebp
jbe 0x100d0
movl $0x1, %esi
xorl %eax, %eax
cmpq %r14, 0x30(%rsp)
jne 0xebb7
movl $0x0, 0xc0(%rbx)
xorl %eax, %eax
jmp 0xebb7
movl %ebp, %eax
xorl $0x1, %eax
orl %r9d, %eax
jne 0xff16
movl %ecx, %eax
testq %rax, %rax
je 0x1028e
leaq (%r14,%rax,8), %rax
addq $0x18, %rax
xorl %esi, %esi
movq %r13, %rcx
movq (%rcx), %rdi
cmpb $0x0, (%rdi)
cmoveq %rdi, %rsi
movq 0x40(%rbx), %rdx
subl 0x38(%rbx), %edi
shrl %edi
shlq $0x4, %rdi
movzwl (%rdx,%rdi), %r8d
testb $0x10, %r8b
jne 0xfeb1
addq %rdi, %rdx
orl $0x10, %r8d
movw %r8w, (%rdx)
incl 0x44c(%rbx)
addq $0x8, %rcx
cmpq %rax, %rcx
jb 0xfe7e
testq %rsi, %rsi
je 0x1028e
movq %r14, %rdx
cmpl $0x2, 0x8(%rsp)
jne 0xff00
movq (%r13), %rax
cmpq %rsi, %rax
jne 0xfeda
movq 0x20(%r14), %rax
cmpb $-0x1, (%rax)
jne 0x102ad
movq 0x38(%rbx), %rcx
subq %rcx, %rax
xorq $0x1, %rax
cmpb $0x1, (%rcx,%rax)
jne 0x102cc
leaq 0x1(,%rax,2), %rdx
movq %rbx, %rdi
callq 0xe4b7
movq 0x8(%rsp), %rcx
movl $0x1, %r9d
movq %r15, %r8
cmpl %ecx, %r8d
jne 0xff4c
cmpq $0x0, 0x250(%rbx)
jne 0xff4c
movq %r14, %rax
cmpq 0x30(%rsp), %r14
jne 0xff45
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq %rbx, %rdi
movl %r9d, %r15d
callq 0xea36
movl %r15d, %r9d
movq %rax, 0x250(%rbx)
orl %r9d, 0x14(%rsp)
jne 0xff62
testl %ebp, %ebp
je 0xff62
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1055a
cmpq 0x30(%rsp), %r14
jne 0xff73
movl $0x0, 0xc0(%rbx)
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4afd(%rip), %rdi      # 0x14a8c
leaq 0x32e6(%rip), %rsi      # 0x1327c
leaq 0x4afa(%rip), %rcx      # 0x14a97
movl $0x65f, %edx            # imm = 0x65F
callq 0x10b0
leaq 0x4947(%rip), %rdi      # 0x148f5
leaq 0x32c7(%rip), %rsi      # 0x1327c
leaq 0x4873(%rip), %rcx      # 0x1482f
movl $0x942, %edx            # imm = 0x942
callq 0x10b0
leaq 0x4909(%rip), %rdi      # 0x148d6
leaq 0x32a8(%rip), %rsi      # 0x1327c
leaq 0x4854(%rip), %rcx      # 0x1482f
movl $0x941, %edx            # imm = 0x941
callq 0x10b0
leaq 0x4a74(%rip), %rdi      # 0x14a60
jmp 0x1001d
leaq 0x445f(%rip), %rdi      # 0x14454
jmp 0x1001d
leaq 0x2c75(%rip), %rdi      # 0x12c73
leaq 0x3277(%rip), %rsi      # 0x1327c
leaq 0x47a6(%rip), %rcx      # 0x147b2
movl $0x6f8, %edx            # imm = 0x6F8
callq 0x10b0
leaq 0x4456(%rip), %rdi      # 0x14473
leaq 0x3258(%rip), %rsi      # 0x1327c
leaq 0x4a0b(%rip), %rcx      # 0x14a36
movl $0x680, %edx            # imm = 0x680
callq 0x10b0
leaq 0x47b3(%rip), %rdi      # 0x147ef
leaq 0x3239(%rip), %rsi      # 0x1327c
leaq 0x4768(%rip), %rcx      # 0x147b2
movl $0x706, %edx            # imm = 0x706
callq 0x10b0
leaq 0x4865(%rip), %rdi      # 0x148c0
leaq 0x321a(%rip), %rsi      # 0x1327c
leaq 0x47c6(%rip), %rcx      # 0x1482f
movl $0x93d, %edx            # imm = 0x93D
callq 0x10b0
leaq 0x48f9(%rip), %rdi      # 0x14973
leaq 0x31fb(%rip), %rsi      # 0x1327c
leaq 0x47a7(%rip), %rcx      # 0x1482f
movl $0x957, %edx            # imm = 0x957
callq 0x10b0
leaq 0x48b3(%rip), %rdi      # 0x1494c
leaq 0x31dc(%rip), %rsi      # 0x1327c
leaq 0x4788(%rip), %rcx      # 0x1482f
movl $0x956, %edx            # imm = 0x956
callq 0x10b0
leaq 0x471b(%rip), %rdi      # 0x147d3
leaq 0x31bd(%rip), %rsi      # 0x1327c
leaq 0x46ec(%rip), %rcx      # 0x147b2
movl $0x704, %edx            # imm = 0x704
callq 0x10b0
leaq 0x4904(%rip), %rdi      # 0x149db
leaq 0x319e(%rip), %rsi      # 0x1327c
leaq 0x474a(%rip), %rcx      # 0x1482f
movl $0x9c3, %edx            # imm = 0x9C3
callq 0x10b0
leaq 0x483a(%rip), %rdi      # 0x14930
leaq 0x317f(%rip), %rsi      # 0x1327c
leaq 0x472b(%rip), %rcx      # 0x1482f
movl $0x949, %edx            # imm = 0x949
callq 0x10b0
leaq 0x46ee(%rip), %rdi      # 0x14803
leaq 0x3160(%rip), %rsi      # 0x1327c
leaq 0x470c(%rip), %rcx      # 0x1482f
movl $0x8fd, %edx            # imm = 0x8FD
callq 0x10b0
leaq 0x4307(%rip), %rdi      # 0x1443b
jmp 0x1001d
leaq 0x4872(%rip), %rdi      # 0x149b2
leaq 0x3135(%rip), %rsi      # 0x1327c
leaq 0x46e1(%rip), %rcx      # 0x1482f
movl $0x989, %edx            # imm = 0x989
callq 0x10b0
leaq 0x4628(%rip), %rdi      # 0x14787
leaq 0x3116(%rip), %rsi      # 0x1327c
leaq 0x46c2(%rip), %rcx      # 0x1482f
movl $0x9ad, %edx            # imm = 0x9AD
callq 0x10b0
leaq 0x45bf(%rip), %rdi      # 0x1473d
leaq 0x30f7(%rip), %rsi      # 0x1327c
leaq 0x46a3(%rip), %rcx      # 0x1482f
movl $0x9ae, %edx            # imm = 0x9AE
callq 0x10b0
leaq 0x4776(%rip), %rdi      # 0x14913
leaq 0x30d8(%rip), %rsi      # 0x1327c
leaq 0x4684(%rip), %rcx      # 0x1482f
movl $0x948, %edx            # imm = 0x948
callq 0x10b0
leaq 0x46d1(%rip), %rdi      # 0x1488d
leaq 0x30b9(%rip), %rsi      # 0x1327c
leaq 0x4665(%rip), %rcx      # 0x1482f
movl $0x92d, %edx            # imm = 0x92D
callq 0x10b0
leaq 0x47bd(%rip), %rdi      # 0x14998
leaq 0x309a(%rip), %rsi      # 0x1327c
leaq 0x4646(%rip), %rcx      # 0x1482f
movl $0x96c, %edx            # imm = 0x96C
callq 0x10b0
leaq 0x46ab(%rip), %rdi      # 0x148a5
leaq 0x307b(%rip), %rsi      # 0x1327c
leaq 0x4627(%rip), %rcx      # 0x1482f
movl $0x935, %edx            # imm = 0x935
callq 0x10b0
leaq 0x48a0(%rip), %rdi      # 0x14ab9
leaq 0x305c(%rip), %rsi      # 0x1327c
leaq 0x48a1(%rip), %rcx      # 0x14ac8
movl $0x534, %edx            # imm = 0x534
callq 0x10b0
leaq 0x4750(%rip), %rdi      # 0x14988
leaq 0x303d(%rip), %rsi      # 0x1327c
leaq 0x45e9(%rip), %rcx      # 0x1482f
movl $0x95c, %edx            # imm = 0x95C
callq 0x10b0
leaq 0x45fe(%rip), %rdi      # 0x14855
leaq 0x301e(%rip), %rsi      # 0x1327c
leaq 0x45ca(%rip), %rcx      # 0x1482f
movl $0x90b, %edx            # imm = 0x90B
callq 0x10b0
leaq 0x45fb(%rip), %rdi      # 0x14871
leaq 0x2fff(%rip), %rsi      # 0x1327c
leaq 0x45ab(%rip), %rcx      # 0x1482f
movl $0x923, %edx            # imm = 0x923
callq 0x10b0
leaq 0x48c7(%rip), %rdi      # 0x14b5c
leaq 0x2fe0(%rip), %rsi      # 0x1327c
leaq 0x458c(%rip), %rcx      # 0x1482f
movl $0x9d9, %edx            # imm = 0x9D9
callq 0x10b0
leaq 0x473b(%rip), %rdi      # 0x149ef
leaq 0x2fc1(%rip), %rsi      # 0x1327c
leaq 0x456d(%rip), %rcx      # 0x1482f
movl $0x9e3, %edx            # imm = 0x9E3
callq 0x10b0
leaq 0x4730(%rip), %rdi      # 0x14a03
leaq 0x2fa2(%rip), %rsi      # 0x1327c
leaq 0x454e(%rip), %rcx      # 0x1482f
movl $0x9e4, %edx            # imm = 0x9E4
callq 0x10b0