// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_perfect_create
int stb_perfect_create(stb_perfect *p, unsigned int *v, int n)
{
   unsigned int buffer1[64], buffer2[64], buffer3[64], buffer4[64], buffer5[32];
   unsigned short *as = (unsigned short *) stb_temp(buffer1, sizeof(*v)*n);
   unsigned short *bs = (unsigned short *) stb_temp(buffer2, sizeof(*v)*n);
   unsigned short *entries = (unsigned short *) stb_temp(buffer4, sizeof(*entries) * n);
   int size = 1 << stb_log2_ceil(n), bsize=8;
   int failure = 0,i,j,k;

   assert(n <= 32768);
   p->large_bmap = NULL;

   for(;;) {
      stb__slot *bcount = (stb__slot *) stb_temp(buffer3, sizeof(*bcount) * bsize);
      unsigned short *bloc = (unsigned short *) stb_temp(buffer5, sizeof(*bloc) * bsize);
      unsigned short *e;
      int bad=0;

      p->addend = stb__perfect_rand();
      p->multiplicand = stb__perfect_rand() | 1;
      p->table_mask = size-1;
      p->b_mask = bsize-1;
      p->table = (stb_uint32 *) malloc(size * sizeof(*p->table));

      for (i=0; i < bsize; ++i) {
         bcount[i].b     = i;
         bcount[i].count = 0;
         bcount[i].map   = 0;
      }
      for (i=0; i < n; ++i) {
         stb__perfect_prehash(p, v[i], as+i, bs+i);
         ++bcount[bs[i]].count;
      }
      qsort(bcount, bsize, sizeof(*bcount), stb__slot_compare);
      e = entries; // now setup up their entries index
      for (i=0; i < bsize; ++i) {
         bcount[i].entries = e;
         e += bcount[i].count;
         bcount[i].count = 0;
         bloc[bcount[i].b] = i;
      }
      // now fill them out
      for (i=0; i < n; ++i) {
         int b = bs[i];
         int w = bloc[b];
         bcount[w].entries[bcount[w].count++] = i;
      }
      stb_tempfree(buffer5,bloc);
      // verify
      for (i=0; i < bsize; ++i)
         for (j=0; j < bcount[i].count; ++j)
            assert(bs[bcount[i].entries[j]] == bcount[i].b);
      memset(p->table, 0, size*sizeof(*p->table));

      // check if any b has duplicate a
      for (i=0; i < bsize; ++i) {
         if (bcount[i].count > 1) {
            for (j=0; j < bcount[i].count; ++j) {
               if (p->table[as[bcount[i].entries[j]]])
                  bad = 1;
               p->table[as[bcount[i].entries[j]]] = 1;
            }
            for (j=0; j < bcount[i].count; ++j) {
               p->table[as[bcount[i].entries[j]]] = 0;
            }
            if (bad) break;
         }
      }

      if (!bad) {
         // go through the bs and populate the table, first fit
         for (i=0; i < bsize; ++i) {
            if (bcount[i].count) {
               // go through the candidate table[b] values
               for (j=0; j < size; ++j) {
                  // go through the a values and see if they fit
                  for (k=0; k < bcount[i].count; ++k) {
                     int a = as[bcount[i].entries[k]];
                     if (p->table[(a^j)&p->table_mask]) {
                        break; // fails
                     }
                  }
                  // if succeeded, accept
                  if (k == bcount[i].count) {
                     bcount[i].map = j;
                     for (k=0; k < bcount[i].count; ++k) {
                        int a = as[bcount[i].entries[k]];
                        p->table[(a^j)&p->table_mask] = 1;
                     }
                     break;
                  }
               }
               if (j == size)
                  break; // no match for i'th entry, so break out in failure
            }
         }
         if (i == bsize) {
            // success... fill out map
            if (bsize <= 16 && size <= 256) {
               p->large_bmap = NULL;
               for (i=0; i < bsize; ++i)
                  p->small_bmap[bcount[i].b] = (stb_uint8) bcount[i].map;
            } else {
               p->large_bmap = (unsigned short *) malloc(sizeof(*p->large_bmap) * bsize);
               for (i=0; i < bsize; ++i)
                  p->large_bmap[bcount[i].b] = bcount[i].map;
            }

            // initialize table to v[0], so empty slots will fail
            for (i=0; i < size; ++i)
               p->table[i] = v[0];

            for (i=0; i < n; ++i)
               if (p->large_bmap)
                  p->table[as[i] ^ p->large_bmap[bs[i]]] = v[i];
               else
                  p->table[as[i] ^ p->small_bmap[bs[i]]] = v[i];

            // and now validate that none of them collided
            for (i=0; i < n; ++i)
               assert(stb_perfect_hash(p, v[i]) >= 0);

            stb_tempfree(buffer3, bcount);
            break;
         }
      }
      free(p->table);
      p->table = NULL;
      stb_tempfree(buffer3, bcount);

      ++failure;
      if (failure >= 4 && bsize < size) bsize *= 2;
      if (failure >= 8 && (failure & 3) == 0 && size < 4*n) {
         size *= 2;
         bsize *= 2;
      }
      if (failure == 6) {
         // make sure the input data is unique, so we don't infinite loop
         unsigned int *data = (unsigned int *) stb_temp(buffer3, n * sizeof(*data));
         memcpy(data, v, sizeof(*data) * n);
         qsort(data, n, sizeof(*data), stb_intcmp(0));
         for (i=1; i < n; ++i) {
            if (data[i] == data[i-1])
               size = 0; // size is return value, so 0 it
         }
         stb_tempfree(buffer3, data);
         if (!size) break;
      }
   }

   if (failure > stb_perfect_hash_max_failures)
      stb_perfect_hash_max_failures = failure;

   stb_tempfree(buffer1, as);
   stb_tempfree(buffer2, bs);
   stb_tempfree(buffer4, entries);

   return size;
}

// Assembly:
subq $0x518, %rsp            # imm = 0x518
movq %rdi, 0x510(%rsp)
movq %rsi, 0x508(%rsp)
movl %edx, 0x504(%rsp)
leaq 0x400(%rsp), %rdi
movslq 0x504(%rsp), %rax
shlq $0x2, %rax
movl %eax, %edx
movl $0x100, %esi            # imm = 0x100
callq 0x3c90
movq %rax, 0x78(%rsp)
leaq 0x300(%rsp), %rdi
movslq 0x504(%rsp), %rax
shlq $0x2, %rax
movl %eax, %edx
movl $0x100, %esi            # imm = 0x100
callq 0x3c90
movq %rax, 0x70(%rsp)
leaq 0x100(%rsp), %rdi
movslq 0x504(%rsp), %rax
shlq %rax
movl %eax, %edx
movl $0x100, %esi            # imm = 0x100
callq 0x3c90
movq %rax, 0x68(%rsp)
movl 0x504(%rsp), %edi
callq 0x47c0
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x64(%rsp)
movl $0x8, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
cmpl $0x8000, 0x504(%rsp) # imm = 0x8000
jg 0x8984
jmp 0x89a3
leaq 0x16c91(%rip), %rdi     # 0x1f61c
leaq 0x169f7(%rip), %rsi     # 0x1f389
movl $0xdeb, %edx            # imm = 0xDEB
leaq 0x16c89(%rip), %rcx     # 0x1f627
callq 0x2140
movq 0x510(%rsp), %rax
movq $0x0, 0x20(%rax)
leaq 0x200(%rsp), %rdi
movslq 0x60(%rsp), %rax
shlq $0x4, %rax
movl %eax, %edx
movl $0x100, %esi            # imm = 0x100
callq 0x3c90
movq %rax, 0x48(%rsp)
leaq 0x80(%rsp), %rdi
movslq 0x60(%rsp), %rax
shlq %rax
movl %eax, %edx
movl $0x80, %esi
callq 0x3c90
movq %rax, 0x40(%rsp)
movl $0x0, 0x34(%rsp)
callq 0x9540
movl %eax, %ecx
movq 0x510(%rsp), %rax
movl %ecx, (%rax)
callq 0x9540
orq $0x1, %rax
movl %eax, %ecx
movq 0x510(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x64(%rsp), %ecx
subl $0x1, %ecx
movq 0x510(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x60(%rsp), %ecx
subl $0x1, %ecx
movq 0x510(%rsp), %rax
movl %ecx, 0x8(%rax)
movslq 0x64(%rsp), %rdi
shlq $0x2, %rdi
callq 0x2260
movq %rax, %rcx
movq 0x510(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x8ace
movl 0x58(%rsp), %eax
movw %ax, %cx
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x2(%rax)
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw $0x0, (%rax)
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw $0x0, 0x4(%rax)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8a6e
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x504(%rsp), %eax
jge 0x8b51
movq 0x510(%rsp), %rdi
movq 0x508(%rsp), %rax
movslq 0x58(%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x78(%rsp), %rdx
movslq 0x58(%rsp), %rax
shlq %rax
addq %rax, %rdx
movq 0x70(%rsp), %rcx
movslq 0x58(%rsp), %rax
shlq %rax
addq %rax, %rcx
callq 0x9580
movq 0x48(%rsp), %rax
movq 0x70(%rsp), %rcx
movslq 0x58(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8ad6
movq 0x48(%rsp), %rdi
movslq 0x60(%rsp), %rsi
movl $0x10, %edx
leaq 0xaa9(%rip), %rcx       # 0x9610
callq 0x20a0
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x8c18
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl (%rax), %ecx
movq 0x38(%rsp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw $0x0, (%rax)
movl 0x58(%rsp), %eax
movw %ax, %dx
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8b7e
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x504(%rsp), %eax
jge 0x8c9f
movq 0x70(%rsp), %rax
movslq 0x58(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movslq 0x30(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x2c(%rsp)
movl 0x58(%rsp), %eax
movw %ax, %dx
movq 0x48(%rsp), %rax
movslq 0x2c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x48(%rsp), %rsi
movslq 0x2c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movw (%rsi), %cx
movw %cx, %di
addw $0x1, %di
movw %di, (%rsi)
movzwl %cx, %ecx
movw %dx, (%rax,%rcx,2)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8c20
leaq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x3cd0
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x8d70
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x8d5e
movq 0x70(%rsp), %rax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x54(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movzwl (%rax,%rcx,2), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x8d2d
jmp 0x8d4c
leaq 0x1692e(%rip), %rdi     # 0x1f662
leaq 0x1664e(%rip), %rsi     # 0x1f389
movl $0xe15, %edx            # imm = 0xE15
leaq 0x168e0(%rip), %rcx     # 0x1f627
callq 0x2140
jmp 0x8d4e
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x8ccf
jmp 0x8d60
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8cb9
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rdi
movslq 0x64(%rsp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2160
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x8efa
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
cmpl $0x1, %eax
jle 0x8ee8
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x8e72
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x48(%rsp), %rdx
movslq 0x58(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movq 0x8(%rdx), %rdx
movslq 0x54(%rsp), %rsi
movzwl (%rdx,%rsi,2), %edx
movzwl (%rcx,%rdx,2), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x8e28
movl $0x1, 0x34(%rsp)
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x48(%rsp), %rdx
movslq 0x58(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movq 0x8(%rdx), %rdx
movslq 0x54(%rsp), %rsi
movzwl (%rdx,%rsi,2), %edx
movzwl (%rcx,%rdx,2), %ecx
movl $0x1, (%rax,%rcx,4)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x8dc7
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x8edd
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x48(%rsp), %rdx
movslq 0x58(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movq 0x8(%rdx), %rdx
movslq 0x54(%rsp), %rsi
movzwl (%rdx,%rsi,2), %edx
movzwl (%rcx,%rdx,2), %ecx
movl $0x0, (%rax,%rcx,4)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x8e7a
cmpl $0x0, 0x34(%rsp)
je 0x8ee6
jmp 0x8efa
jmp 0x8ee8
jmp 0x8eea
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8d94
cmpl $0x0, 0x34(%rsp)
jne 0x935e
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x90c7
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpw $0x0, (%rax)
je 0x90b5
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x90a7
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x8fd3
movq 0x78(%rsp), %rax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x50(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x28(%rsp)
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x28(%rsp), %ecx
xorl 0x54(%rsp), %ecx
movq 0x510(%rsp), %rdx
andl 0x28(%rdx), %ecx
movl %ecx, %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x8fc4
jmp 0x8fd3
jmp 0x8fc6
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x8f54
movl 0x50(%rsp), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x9095
movl 0x54(%rsp), %eax
movw %ax, %cx
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x4(%rax)
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x9093
movq 0x78(%rsp), %rax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movslq 0x50(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x24(%rsp)
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x24(%rsp), %ecx
xorl 0x54(%rsp), %ecx
movq 0x510(%rsp), %rdx
andl 0x28(%rdx), %ecx
movl %ecx, %ecx
movl $0x1, (%rax,%rcx,4)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x9017
jmp 0x90a7
jmp 0x9097
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x8f3e
movl 0x54(%rsp), %eax
cmpl 0x64(%rsp), %eax
jne 0x90b3
jmp 0x90c7
jmp 0x90b5
jmp 0x90b7
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x8f0d
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jne 0x935c
cmpl $0x10, 0x60(%rsp)
jg 0x914f
cmpl $0x100, 0x64(%rsp)      # imm = 0x100
jg 0x914f
movq 0x510(%rsp), %rax
movq $0x0, 0x20(%rax)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x914d
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x4(%rax), %ax
movb %al, %dl
movq 0x510(%rsp), %rax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movzwl 0x2(%rcx), %ecx
movb %dl, 0xc(%rax,%rcx)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x90fe
jmp 0x91c6
movslq 0x60(%rsp), %rdi
shlq %rdi
callq 0x2260
movq %rax, %rcx
movq 0x510(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x91c4
movq 0x48(%rsp), %rax
movslq 0x58(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x4(%rax), %dx
movq 0x510(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x48(%rsp), %rcx
movslq 0x58(%rsp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x9173
jmp 0x91c6
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x9203
movq 0x508(%rsp), %rax
movl (%rax), %edx
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x58(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x91ce
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x504(%rsp), %eax
jge 0x92de
movq 0x510(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x927e
movq 0x508(%rsp), %rax
movslq 0x58(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x78(%rsp), %rcx
movslq 0x58(%rsp), %rsi
movzwl (%rcx,%rsi,2), %ecx
movq 0x510(%rsp), %rsi
movq 0x20(%rsi), %rsi
movq 0x70(%rsp), %rdi
movslq 0x58(%rsp), %r8
movzwl (%rdi,%r8,2), %edi
movzwl (%rsi,%rdi,2), %esi
xorl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x92cc
movq 0x508(%rsp), %rax
movslq 0x58(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x78(%rsp), %rcx
movslq 0x58(%rsp), %rsi
movzwl (%rcx,%rsi,2), %ecx
movq 0x510(%rsp), %rsi
movq 0x70(%rsp), %rdi
movslq 0x58(%rsp), %r8
movzwl (%rdi,%r8,2), %edi
movzbl 0xc(%rsi,%rdi), %esi
xorl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x92ce
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x920b
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x504(%rsp), %eax
jge 0x9345
movq 0x510(%rsp), %rdi
movq 0x508(%rsp), %rax
movslq 0x58(%rsp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x87c0
cmpl $0x0, %eax
jl 0x9317
jmp 0x9336
leaq 0x1636c(%rip), %rdi     # 0x1f68a
leaq 0x16064(%rip), %rsi     # 0x1f389
movl $0xe5a, %edx            # imm = 0xE5A
leaq 0x162f6(%rip), %rcx     # 0x1f627
callq 0x2140
jmp 0x9338
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x92e6
leaq 0x200(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x3cd0
jmp 0x94e2
jmp 0x935e
movq 0x510(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x23c0
movq 0x510(%rsp), %rax
movq $0x0, 0x30(%rax)
leaq 0x200(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x3cd0
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
cmpl $0x4, 0x5c(%rsp)
jl 0x93b7
movl 0x60(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x93b7
movl 0x60(%rsp), %eax
shll %eax
movl %eax, 0x60(%rsp)
cmpl $0x8, 0x5c(%rsp)
jl 0x93f0
movl 0x5c(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x93f0
movl 0x64(%rsp), %eax
movl 0x504(%rsp), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jge 0x93f0
movl 0x64(%rsp), %eax
shll %eax
movl %eax, 0x64(%rsp)
movl 0x60(%rsp), %eax
shll %eax
movl %eax, 0x60(%rsp)
cmpl $0x6, 0x5c(%rsp)
jne 0x94dd
leaq 0x200(%rsp), %rdi
movslq 0x504(%rsp), %rax
shlq $0x2, %rax
movl %eax, %edx
movl $0x100, %esi            # imm = 0x100
callq 0x3c90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x508(%rsp), %rsi
movslq 0x504(%rsp), %rdx
shlq $0x2, %rdx
callq 0x2230
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x504(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %edi, %edi
callq 0x4ae0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rcx
movl $0x4, %edx
callq 0x20a0
movl $0x1, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x504(%rsp), %eax
jge 0x94c0
movq 0x18(%rsp), %rax
movslq 0x58(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x18(%rsp), %rcx
movl 0x58(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x94b1
movl $0x0, 0x64(%rsp)
jmp 0x94b3
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x947b
leaq 0x200(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3cd0
cmpl $0x0, 0x64(%rsp)
jne 0x94db
jmp 0x94e2
jmp 0x94dd
jmp 0x89b3
movl 0x5c(%rsp), %eax
cmpl 0x20ba4(%rip), %eax     # 0x2a090
jle 0x94f8
movl 0x5c(%rsp), %eax
movl %eax, 0x20b98(%rip)     # 0x2a090
leaq 0x400(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x3cd0
leaq 0x300(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x3cd0
leaq 0x100(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x3cd0
movl 0x64(%rsp), %eax
addq $0x518, %rsp            # imm = 0x518
retq
nopw (%rax,%rax)