// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_sortbench.c
// Function: gt_sortbench_runner
static int gt_sortbench_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
                                GT_UNUSED int parsed_args,
                                void *tool_arguments, GT_UNUSED GtError *err)
{
  QSortBenchArguments *arguments = tool_arguments;
  int had_err = 0;
  size_t method;
  GtTimer *timer;
  GtUword *array = NULL, *array_copy = NULL, idx, r;
  Gtuint64keyPair *arraykeypair = NULL, *arraykeypair_copy = NULL;
  uint8_t *flba = NULL;
  size_t flba_unitsize = 0;

  gt_error_check(err);
  gt_assert(arguments);
  if (arguments->verbose) {
    printf("# number of items = "GT_WU"\n", arguments->num_values);
    printf("# max value items = "GT_WU"\n", arguments->maxvalue);
    printf("# implementation = %s\n", gt_str_get(arguments->impl));
  }

  /* prepare benchmark input data */
  if (strcmp(gt_str_get(arguments->impl),"radixkeypair") == 0)
  {
    arraykeypair = gt_malloc(sizeof (*arraykeypair) * arguments->num_values);
  } else
  {
    bool alloc_array;
    if (strcmp(gt_str_get(arguments->impl),"radixflba") == 0)
    {
      size_t bits = gt_radixsort_bits(arguments->maxvalue);
      flba_unitsize = gt_radixsort_bits2bytes(bits);
      flba = gt_malloc(sizeof (*flba) * arguments->num_values * flba_unitsize);
      alloc_array = arguments->verify;
    } else
    {
      alloc_array = true;
    }
    if (alloc_array)
    {
      array = gt_malloc(sizeof (*array) * arguments->num_values);
    }
  }
  if (arguments->use_aqsort)
  {
    if (arguments->verbose)
    {
      printf("# using aqsort\n");
    }
    gt_assert(array != NULL);
    gt_sortbench_aqsort(arguments->num_values, array);
  } else
  {
    if (arguments->use_permute)
    {
      if (arguments->verbose)
      {
        printf("# using permuted array\n");
      }
      gt_assert(array != NULL);
      for (idx = 0; idx < arguments->num_values; idx++)
      {
        array[idx] = idx;
      }
      gt_qbenchsort_permute_ulong_array(array, arguments->num_values);
    } else
    {
      if (arguments->verbose)
      {
        printf("# using simple array of random numbers\n");
      }
      if (arraykeypair != NULL)
      {
        for (idx = 0; idx < arguments->num_values; idx++)
        {
          arraykeypair[idx].uint64_a = random() % (arguments->maxvalue+1);
          arraykeypair[idx].uint64_b = random() % (arguments->maxvalue+1);
        }
      } else
      {
        if (flba != NULL)
        {
          uint8_t *flba_buffer = gt_malloc(sizeof *flba_buffer * flba_unitsize);
          gt_assert(!arguments->verify || array != NULL);
          for (idx = 0; idx < arguments->num_values; idx++)
          {
            GtUword value = (GtUword) (random() % (arguments->maxvalue+1));
            gt_uword2flba(flba_buffer,value,flba_unitsize);
            memcpy(flba + idx * flba_unitsize,flba_buffer,flba_unitsize);
            if (arguments->verify)
            {
              array[idx] = value;
            }
          }
          gt_free(flba_buffer);
        } else
        {
          gt_assert(array != NULL);
          for (idx = 0; idx < arguments->num_values; idx++)
          {
            array[idx] = random() % (arguments->maxvalue+1);
          }
        }
      }
    }
  }
  if (arguments->verify)
  {
    if (arraykeypair != NULL)
    {
      arraykeypair_copy = gt_malloc(sizeof (*arraykeypair_copy) *
                                    arguments->num_values);
      for (idx = 0; idx < arguments->num_values; idx++)
      {
        arraykeypair_copy[idx] = arraykeypair[idx];
      }
      qsort(arraykeypair_copy,(size_t) arguments->num_values,
            sizeof *arraykeypair_copy,
            voidkeypairqsortcmp);
    } else
    {
      if (flba != NULL)
      {
        gt_assert(array != NULL);
        qsort(array,(size_t) arguments->num_values,sizeof *array,voidqsortcmp);
      } else
      {
        array_copy = gt_malloc(sizeof (*array_copy) * arguments->num_values);
        gt_assert(array != NULL);
        for (idx = 0; idx < arguments->num_values; idx++)
        {
          array_copy[idx] = array[idx];
        }
        qsort(array_copy,(size_t) arguments->num_values,sizeof *array_copy,
              voidqsortcmp);
      }
    }
  }
  timer = gt_timer_new();
  gt_timer_start(timer);
  /* run implementation */
  if (arraykeypair != NULL)
  {
    for (r = 0; r < arguments->runs; r++)
    {
      gt_radixsort_inplace_Gtuint64keyPair(arraykeypair,arguments->num_values);
    }
  } else
  {
    if (flba != NULL)
    {
      gt_assert(flba_unitsize > 0);
      gt_radixsort_inplace_flba(flba,arguments->num_values,flba_unitsize);
    } else
    {
      for (method = 0; method < GT_NUM_OF_SORT_IMPLEMENTATIONS; method++)
      {
        if (strcmp(gt_str_get(arguments->impl),
                   gt_sort_implementation_names[method]) == 0)
        {
          for (r = 0; r < arguments->runs; r++)
          {
            gt_assert(array != NULL && arraykeypair == NULL);
            gt_assert(method < GT_NUM_OF_SORT_IMPLEMENTATIONS);
            gt_sort_implementation_funcs[method](array, arguments->num_values);
          }
          break;
        }
      }
    }
  }
  printf("# TIME %s-t%u-r" GT_WU "-n" GT_WU " overall ",
          gt_str_get(arguments->impl),
#ifdef GT_THREADS_ENABLED
          gt_jobs,
#else
          1U,
#endif
          arguments->runs,arguments->num_values);
  gt_timer_show_formatted(timer,GT_WD ".%02ld\n",stdout);
  gt_timer_delete(timer);
  if (arguments->verify)
  {
    if (arraykeypair != NULL)
    {
      gt_sortbench_verify_keypair(arraykeypair,arraykeypair_copy,
                                  arguments->num_values);
    } else
    {
      if (flba != NULL)
      {
        gt_assert(array != NULL);
        gt_sortbench_verify_flba(flba,array,arguments->num_values,
                                 flba_unitsize);
      } else
      {
        gt_sortbench_verify(array,array_copy,arguments->num_values);
      }
    }
  }
  gt_free(flba);
  gt_free(array);
  gt_free(array_copy);
  gt_free(arraykeypair);
  gt_free(arraykeypair_copy);
  if (cmpcount > 0)
  {
    printf("cmpcount = "GT_WU"\n",cmpcount);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r12
testq %r8, %r8
je 0xccc69
movq %r8, %rdi
callq 0x101a9a
testb %al, %al
jne 0xcd96c
testq %r12, %r12
je 0xcd967
cmpb $0x1, 0x23(%r12)
jne 0xcccba
movq 0x8(%r12), %rsi
leaq 0x29789a(%rip), %rdi    # 0x364520
xorl %eax, %eax
callq 0x17070
movq 0x18(%r12), %rsi
leaq 0x2978a0(%rip), %rdi    # 0x364539
xorl %eax, %eax
callq 0x17070
movq (%r12), %rdi
callq 0x120d23
leaq 0x2978a2(%rip), %rdi    # 0x364552
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movq (%r12), %rdi
callq 0x120d23
leaq 0x2977a4(%rip), %rsi    # 0x36446e
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xccd02
movq (%r12), %rdi
callq 0x120d23
leaq 0x2977dc(%rip), %rsi    # 0x3644c2
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xccd2d
movb $0x1, %al
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
jmp 0xccd66
movq 0x8(%r12), %rdi
shlq $0x4, %rdi
leaq 0x2974ae(%rip), %rsi    # 0x3641c0
movl $0x253, %edx            # imm = 0x253
callq 0x1092b2
movq %rax, %rbx
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
jmp 0xccd8d
movq 0x18(%r12), %rdi
callq 0x115467
movq %rax, %rdi
callq 0x1154b4
movq %rax, %r13
movq %rax, %rdi
imulq 0x8(%r12), %rdi
leaq 0x29746e(%rip), %rsi    # 0x3641c0
movl $0x25b, %edx            # imm = 0x25B
callq 0x1092b2
movq %rax, 0x8(%rsp)
movb 0x22(%r12), %al
testb %al, %al
je 0xccd8b
movq 0x8(%r12), %rdi
shlq $0x3, %rdi
leaq 0x297446(%rip), %rsi    # 0x3641c0
movl $0x263, %edx            # imm = 0x263
callq 0x1092b2
movq %rax, %r15
xorl %ebx, %ebx
jmp 0xccd90
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpb $0x1, 0x20(%r12)
movq %rbx, 0x20(%rsp)
jne 0xcce93
cmpb $0x1, 0x23(%r12)
jne 0xccdb5
leaq 0x297beb(%rip), %rdi    # 0x36499b
callq 0x17bd0
testq %r15, %r15
je 0xcd971
movq 0x8(%r12), %rbx
leaq (,%rbx,8), %rdi
leaq 0x2973ee(%rip), %rsi    # 0x3641c0
movl $0xde, %edx
callq 0x1092b2
movq %rax, %rbp
leaq 0x3fc68a(%rip), %r14    # 0x4c9470
movq %r15, (%r14)
xorl %eax, %eax
movq %rbx, %rcx
leaq 0x3fc693(%rip), %rdx    # 0x4c9488
movq %rax, (%rdx)
leaq 0x3fc679(%rip), %rdx    # 0x4c9478
movq %rax, (%rdx)
leaq 0x3fc677(%rip), %rdx    # 0x4c9480
movq %rax, (%rdx)
leaq 0x3fc67d(%rip), %rax    # 0x4c9490
subq $0x1, %rcx
movq %rcx, (%rax)
jb 0xcce32
xorl %ecx, %ecx
movq %rcx, (%rbp,%rcx,8)
movq (%rax), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0xcce1e
leaq 0xba8(%rip), %rcx       # 0xcd9e1
movl $0x8, %edx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x17f60
cmpq $0x2, %rbx
jb 0xcce7a
movq (%r14), %rax
movl $0x1, %ecx
movq -0x8(%rbp,%rcx,8), %rdx
movq (%rbp,%rcx,8), %rsi
movq (%rax,%rdx,8), %rdx
incq %rdx
cmpq %rdx, (%rax,%rsi,8)
jne 0xcd912
incq %rcx
cmpq %rcx, %rbx
jne 0xcce57
leaq 0x29733f(%rip), %rsi    # 0x3641c0
movq %rbp, %rdi
movl $0xea, %edx
callq 0x109670
jmp 0xccf76
movb 0x23(%r12), %al
cmpb $0x1, 0x21(%r12)
jne 0xccf07
testb %al, %al
je 0xcceb0
leaq 0x297ad9(%rip), %rdi    # 0x364984
callq 0x17bd0
testq %r15, %r15
je 0xcd976
movq 0x8(%r12), %r14
testq %r14, %r14
je 0xcced6
xorl %eax, %eax
movq %rax, (%r15,%rax,8)
incq %rax
movq 0x8(%r12), %r14
cmpq %r14, %rax
jb 0xccec5
testq %r14, %r14
je 0xccf76
leaq -0x1(%r14), %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x10ae3c
movq (%r15,%rbp,8), %rcx
movq (%r15,%rax,8), %rdx
movq %rdx, (%r15,%rbp,8)
movq %rcx, (%r15,%rax,8)
incq %rbp
cmpq %rbp, %r14
jne 0xccee5
jmp 0xccf76
testb %al, %al
je 0xccf17
leaq 0x297a4b(%rip), %rdi    # 0x36495d
callq 0x17bd0
testq %rbx, %rbx
je 0xcd0e2
cmpq $0x0, 0x8(%r12)
je 0xccf76
movq 0x20(%rsp), %rax
leaq 0x8(%rax), %rbx
xorl %r14d, %r14d
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
callq 0x125bcc
andl %ebp, %eax
movq 0x18(%r12), %rcx
incq %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x8(%rbx)
callq 0x125bcc
andl %ebp, %eax
movq 0x18(%r12), %rcx
incq %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, (%rbx)
incq %r14
addq $0x10, %rbx
cmpq 0x8(%r12), %r14
jb 0xccf39
movq %r15, 0x10(%rsp)
cmpb $0x1, 0x22(%r12)
jne 0xccfeb
movq 0x20(%rsp), %r15
testq %r15, %r15
je 0xccffd
movq 0x8(%r12), %rdi
shlq $0x4, %rdi
leaq 0x297223(%rip), %rsi    # 0x3641c0
movl $0x2aa, %edx            # imm = 0x2AA
callq 0x1092b2
movq %rax, %rbp
movq 0x8(%r12), %rsi
testq %rsi, %rsi
je 0xccfd5
xorl %eax, %eax
xorl %ecx, %ecx
movdqu (%r15,%rax), %xmm0
movdqu %xmm0, (%rbp,%rax)
incq %rcx
movq 0x8(%r12), %rsi
addq $0x10, %rax
cmpq %rsi, %rcx
jb 0xccfb8
leaq 0x9c7(%rip), %rcx       # 0xcd9a3
movl $0x10, %edx
movq %rbp, %rdi
callq 0x17f60
jmp 0xcd02f
xorl %ebp, %ebp
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %r15
jmp 0xcd038
cmpq $0x0, 0x8(%rsp)
je 0xcd78c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd980
movq 0x8(%r12), %rsi
leaq 0x9aa(%rip), %rcx       # 0xcd9cd
movl $0x8, %edx
callq 0x17f60
xorl %ebp, %ebp
movq $0x0, 0x18(%rsp)
callq 0x1226a4
movq %rax, 0x28(%rsp)
movq %rax, %rdi
callq 0x122733
testq %r15, %r15
je 0xcd07a
cmpq $0x0, 0x10(%r12)
je 0xcd5fd
xorl %r14d, %r14d
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x115391
incq %r14
cmpq 0x10(%r12), %r14
jb 0xcd05e
jmp 0xcd5fd
cmpq $0x0, 0x8(%rsp)
je 0xcd0a7
testq %r13, %r13
je 0xcd97b
movq 0x8(%r12), %rsi
movq 0x8(%rsp), %rdi
movq %r13, %rdx
callq 0x1153d3
movq 0x20(%rsp), %r15
jmp 0xcd5fd
xorl %r14d, %r14d
leaq 0x3f78df(%rip), %rbx    # 0x4c4990
movq 0x20(%rsp), %r15
movq (%r12), %rdi
callq 0x120d23
movq (%r14,%rbx), %rsi
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xcd5bb
addq $0x8, %r14
cmpq $0x40, %r14
jne 0xcd0b6
jmp 0xcd5fd
cmpq $0x0, 0x8(%rsp)
je 0xcd8d1
leaq 0x2970cb(%rip), %rsi    # 0x3641c0
movq %r13, %rdi
movl $0x28d, %edx            # imm = 0x28D
callq 0x1092b2
movq %rax, %rbx
cmpb $0x1, 0x22(%r12)
jne 0xcd116
testq %r15, %r15
je 0xcd994
cmpq $0x0, 0x8(%r12)
je 0xcd5a7
leaq -0x1(%r13), %rax
leal (,%r13,8), %ecx
movq $-0x1, %rdx
shlq %cl, %rdx
xorl %ecx, %ecx
cmpq $0x8, %r13
cmoveq %rcx, %rdx
movq %rdx, 0x28(%rsp)
leal 0x7(%r13), %r14d
andl $0x18, %r14d
movq %r13, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psllq $0x3, %xmm0
movdqa 0x296fba(%rip), %xmm1   # 0x364120
paddq %xmm0, %xmm1
movdqa %xmm1, 0x50(%rsp)
movdqa 0x296fb8(%rip), %xmm1   # 0x364130
paddq %xmm0, %xmm1
movdqa %xmm1, 0x40(%rsp)
movdqa 0x296fb6(%rip), %xmm1   # 0x364140
paddq %xmm0, %xmm1
movdqa %xmm1, 0x30(%rsp)
paddq 0x296fb4(%rip), %xmm0   # 0x364150
movdqa %xmm0, 0x60(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
pxor 0x2948c7(%rip), %xmm0   # 0x361a80
movdqa %xmm0, 0x70(%rsp)
movq %rcx, 0x10(%rsp)
callq 0x125bcc
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq 0x18(%r12), %rcx
incq %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x8, 0x18(%rsp)
jae 0xcd95d
movq %rdx, %rbp
testq %rdx, 0x28(%rsp)
jne 0xcd952
testq %r13, %r13
movdqa 0x70(%rsp), %xmm14
movdqa 0x294878(%rip), %xmm15  # 0x361a80
je 0xcd56f
xorl %eax, %eax
movdqa 0x60(%rsp), %xmm0
movdqa 0x30(%rsp), %xmm1
movdqa 0x40(%rsp), %xmm2
movdqa 0x50(%rsp), %xmm3
movdqa 0x294840(%rip), %xmm4   # 0x361a70
movdqa 0x296f48(%rip), %xmm5   # 0x364180
movdqa 0x296f30(%rip), %xmm6   # 0x364170
movdqa 0x296f18(%rip), %xmm7   # 0x364160
movdqa %xmm4, %xmm8
pxor %xmm15, %xmm8
movdqa %xmm8, %xmm9
pcmpgtd %xmm14, %xmm9
pshufd $0xa0, %xmm9, %xmm10    # xmm10 = xmm9[0,0,2,2]
pshuflw $0xe8, %xmm10, %xmm11   # xmm11 = xmm10[0,2,2,3,4,5,6,7]
pcmpeqd %xmm14, %xmm8
pshufd $0xf5, %xmm8, %xmm8     # xmm8 = xmm8[1,1,3,3]
pshuflw $0xe8, %xmm8, %xmm12    # xmm12 = xmm8[0,2,2,3,4,5,6,7]
pand %xmm11, %xmm12
pshufd $0xf5, %xmm9, %xmm11    # xmm11 = xmm9[1,1,3,3]
pshuflw $0xe8, %xmm11, %xmm13   # xmm13 = xmm11[0,2,2,3,4,5,6,7]
por %xmm12, %xmm13
pxor 0x290d48(%rip), %xmm13  # 0x35dfe0
packssdw %xmm13, %xmm13
movdqa %xmm0, %xmm9
paddq 0x296ee5(%rip), %xmm9   # 0x364190
movd %xmm13, %ecx
testb $0x1, %cl
je 0xcd2c3
movq %xmm9, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, (%rbx,%rax)
pand %xmm10, %xmm8
por %xmm11, %xmm8
packssdw %xmm8, %xmm8
pcmpeqd %xmm13, %xmm13
pxor %xmm13, %xmm8
packssdw %xmm8, %xmm8
movd %xmm8, %ecx
shrl $0x10, %ecx
testb $0x1, %cl
je 0xcd303
pshufd $0xee, %xmm9, %xmm8     # xmm8 = xmm9[2,3,2,3]
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x1(%rbx,%rax)
movdqa %xmm1, %xmm8
paddq 0x296e7f(%rip), %xmm8   # 0x364190
movdqa %xmm5, %xmm10
pxor %xmm15, %xmm10
movdqa %xmm10, %xmm11
pcmpgtd %xmm14, %xmm11
pshufd $0xa0, %xmm11, %xmm9    # xmm9 = xmm11[0,0,2,2]
pcmpeqd %xmm14, %xmm10
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
movdqa %xmm10, %xmm12
pand %xmm9, %xmm12
pshufd $0xf5, %xmm11, %xmm11   # xmm11 = xmm11[1,1,3,3]
por %xmm11, %xmm12
packssdw %xmm12, %xmm12
pxor %xmm13, %xmm12
packssdw %xmm12, %xmm12
pextrw $0x2, %xmm12, %ecx
testb $0x1, %cl
je 0xcd374
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x2(%rbx,%rax)
pshufhw $0x84, %xmm9, %xmm9     # xmm9 = xmm9[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm10, %xmm10   # xmm10 = xmm10[0,1,2,3,4,5,4,6]
pand %xmm9, %xmm10
pshufhw $0x84, %xmm11, %xmm9    # xmm9 = xmm11[0,1,2,3,4,5,4,6]
por %xmm10, %xmm9
pxor %xmm13, %xmm9
packssdw %xmm9, %xmm9
pextrw $0x3, %xmm9, %ecx
testb $0x1, %cl
je 0xcd3ba
pshufd $0xee, %xmm8, %xmm8     # xmm8 = xmm8[2,3,2,3]
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x3(%rbx,%rax)
movdqa %xmm2, %xmm8
paddq 0x296dc8(%rip), %xmm8   # 0x364190
movdqa %xmm6, %xmm9
pxor %xmm15, %xmm9
movdqa %xmm9, %xmm11
pcmpgtd %xmm14, %xmm11
pshufd $0xa0, %xmm11, %xmm10   # xmm10 = xmm11[0,0,2,2]
pshuflw $0xe8, %xmm10, %xmm12   # xmm12 = xmm10[0,2,2,3,4,5,6,7]
pcmpeqd %xmm14, %xmm9
pshufd $0xf5, %xmm9, %xmm9     # xmm9 = xmm9[1,1,3,3]
pshuflw $0xe8, %xmm9, %xmm13    # xmm13 = xmm9[0,2,2,3,4,5,6,7]
pand %xmm12, %xmm13
pshufd $0xf5, %xmm11, %xmm11   # xmm11 = xmm11[1,1,3,3]
pshuflw $0xe8, %xmm11, %xmm12   # xmm12 = xmm11[0,2,2,3,4,5,6,7]
por %xmm13, %xmm12
pcmpeqd %xmm13, %xmm13
pxor %xmm13, %xmm12
packssdw %xmm12, %xmm12
pextrw $0x4, %xmm12, %ecx
testb $0x1, %cl
je 0xcd438
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x4(%rbx,%rax)
pand %xmm10, %xmm9
por %xmm11, %xmm9
packssdw %xmm9, %xmm9
pxor %xmm13, %xmm9
packssdw %xmm9, %xmm9
pextrw $0x5, %xmm9, %ecx
testb $0x1, %cl
je 0xcd471
pshufd $0xee, %xmm8, %xmm8     # xmm8 = xmm8[2,3,2,3]
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x5(%rbx,%rax)
movdqa %xmm3, %xmm8
paddq 0x296d11(%rip), %xmm8   # 0x364190
movdqa %xmm7, %xmm10
pxor %xmm15, %xmm10
movdqa %xmm10, %xmm11
pcmpgtd %xmm14, %xmm11
pshufd $0xa0, %xmm11, %xmm9    # xmm9 = xmm11[0,0,2,2]
pcmpeqd %xmm14, %xmm10
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
movdqa %xmm10, %xmm12
pand %xmm9, %xmm12
pshufd $0xf5, %xmm11, %xmm11   # xmm11 = xmm11[1,1,3,3]
por %xmm11, %xmm12
packssdw %xmm12, %xmm12
pxor %xmm13, %xmm12
packssdw %xmm12, %xmm12
pextrw $0x6, %xmm12, %ecx
testb $0x1, %cl
je 0xcd4e2
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x6(%rbx,%rax)
pshufhw $0x84, %xmm9, %xmm9     # xmm9 = xmm9[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm10, %xmm10   # xmm10 = xmm10[0,1,2,3,4,5,4,6]
pand %xmm9, %xmm10
pshufhw $0x84, %xmm11, %xmm9    # xmm9 = xmm11[0,1,2,3,4,5,4,6]
por %xmm10, %xmm9
pxor %xmm13, %xmm9
packssdw %xmm9, %xmm9
pextrw $0x7, %xmm9, %ecx
testb $0x1, %cl
je 0xcd528
pshufd $0xee, %xmm8, %xmm8     # xmm8 = xmm8[2,3,2,3]
movq %xmm8, %rcx
movq %rbp, %rdx
shrq %cl, %rdx
movb %dl, 0x7(%rbx,%rax)
addq $0x8, %rax
movdqa 0x296c6b(%rip), %xmm8   # 0x3641a0
paddq %xmm8, %xmm0
paddq %xmm8, %xmm1
paddq %xmm8, %xmm2
paddq %xmm8, %xmm3
movdqa 0x296c5e(%rip), %xmm8   # 0x3641b0
paddq %xmm8, %xmm4
paddq %xmm8, %xmm5
paddq %xmm8, %xmm6
paddq %xmm8, %xmm7
cmpq %rax, %r14
jne 0xcd248
movq 0x10(%rsp), %rdi
imulq %r13, %rdi
addq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x17660
movq 0x10(%rsp), %rcx
cmpb $0x1, 0x22(%r12)
jne 0xcd599
movq %rbp, (%r15,%rcx,8)
incq %rcx
cmpq 0x8(%r12), %rcx
jb 0xcd1bf
leaq 0x296c12(%rip), %rsi    # 0x3641c0
movq %rbx, %rdi
movl $0x299, %edx            # imm = 0x299
jmp 0xcce89
cmpq $0x0, 0x10(%r12)
movq 0x20(%rsp), %r15
je 0xcd5fd
cmpq $0x0, 0x10(%rsp)
je 0xcd999
leaq 0x3f0f45(%rip), %rax    # 0x4be520
movq (%r14,%rax), %r14
xorl %ebx, %ebx
movq 0x20(%rsp), %r15
movq 0x8(%r12), %rsi
movq 0x10(%rsp), %rdi
callq *%r14
incq %rbx
cmpq 0x10(%r12), %rbx
jb 0xcd5e6
movq (%r12), %rdi
callq 0x120d23
leaq 0x3f780b(%rip), %rcx    # 0x4c4e18
movl (%rcx), %edx
movq 0x8(%r12), %r8
movq 0x10(%r12), %rcx
leaq 0x296fa5(%rip), %rdi    # 0x3645c5
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x3f68b7(%rip), %rax    # 0x4c3ee8
movq (%rax), %rdx
leaq 0x28bc07(%rip), %rsi    # 0x359242
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1227b4
movq %rbx, %rdi
callq 0x122d79
cmpb $0x1, 0x22(%r12)
movq %r15, %r14
movq 0x10(%rsp), %r15
jne 0xcd848
testq %r14, %r14
je 0xcd715
movq 0x8(%r12), %rax
cmpq $0x2, %rax
jb 0xcd6da
leaq -0x1(%rax), %rcx
movq %r14, %rdx
movq 0x10(%rdx), %rsi
cmpq %rsi, (%rdx)
jb 0xcd69c
jne 0xcd926
movq 0x8(%rdx), %rsi
cmpq 0x18(%rdx), %rsi
ja 0xcd926
movl 0x14(%rdx), %esi
cmpl %esi, 0x4(%rdx)
jb 0xcd6d1
ja 0xcd921
movl 0x10(%rdx), %esi
cmpl %esi, (%rdx)
jb 0xcd6d1
ja 0xcd921
movl 0x1c(%rdx), %esi
cmpl %esi, 0xc(%rdx)
jb 0xcd6d1
ja 0xcd921
movl 0x8(%rdx), %esi
cmpl 0x18(%rdx), %esi
ja 0xcd921
addq $0x10, %rdx
decq %rcx
jne 0xcd67f
testq %rax, %rax
je 0xcd83c
movl $0x8, %ecx
movq -0x8(%r14,%rcx), %rdx
cmpq -0x8(%rbp,%rcx), %rdx
jne 0xcd91c
movq (%r14,%rcx), %rdx
cmpq (%rbp,%rcx), %rdx
jne 0xcd917
addq $0x10, %rcx
decq %rax
jne 0xcd6e8
jmp 0xcd83c
cmpq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rsi
je 0xcd7f8
testq %r15, %r15
je 0xcd985
movq 0x8(%r12), %rax
testq %rax, %rax
je 0xcd83c
leaq -0x1(%r13), %rcx
cmpq $0x7, %rcx
ja 0xcd98a
xorl %r8d, %r8d
movq 0x8(%rsp), %rsi
xorl %edx, %edx
testq %r13, %r13
je 0xcd76f
xorl %ecx, %ecx
shlq $0x8, %rdx
movzbl (%rsi,%rcx), %edi
orq %rdi, %rdx
incq %rcx
cmpq %rcx, %r13
jne 0xcd75c
movq (%r15,%r8,8), %rcx
cmpq %rcx, %rdx
jne 0xcd92b
incq %r8
addq %r13, %rsi
cmpq %rax, %r8
jne 0xcd753
jmp 0xcd83c
movq 0x8(%r12), %rdi
shlq $0x3, %rdi
leaq 0x296a24(%rip), %rsi    # 0x3641c0
movl $0x2ba, %edx            # imm = 0x2BA
callq 0x1092b2
cmpq $0x0, 0x10(%rsp)
je 0xcd98f
movq %rax, %rdi
movq 0x8(%r12), %rsi
testq %rsi, %rsi
movq 0x10(%rsp), %rdx
je 0xcd7db
xorl %eax, %eax
movq (%rdx,%rax,8), %rcx
movq %rcx, (%rdi,%rax,8)
incq %rax
movq 0x8(%r12), %rsi
cmpq %rsi, %rax
jb 0xcd7c6
leaq 0x1eb(%rip), %rcx       # 0xcd9cd
movl $0x8, %edx
movq %rdi, 0x18(%rsp)
callq 0x17f60
xorl %ebp, %ebp
jmp 0xcd038
movq 0x8(%r12), %rax
cmpq $0x2, %rax
jb 0xcd81f
movl $0x1, %ecx
movq -0x8(%r15,%rcx,8), %rdx
cmpq (%r15,%rcx,8), %rdx
ja 0xcd962
incq %rcx
cmpq %rcx, %rax
jne 0xcd808
testq %rax, %rax
je 0xcd83c
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
cmpq (%rsi,%rcx,8), %rdx
ja 0xcd94d
incq %rcx
cmpq %rcx, %rax
jne 0xcd826
leaq 0x297167(%rip), %rdi    # 0x3649aa
callq 0x17bd0
leaq 0x296971(%rip), %rbx    # 0x3641c0
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x303, %edx            # imm = 0x303
callq 0x109670
movq %r15, %rdi
movq %rbx, %rsi
movl $0x304, %edx            # imm = 0x304
callq 0x109670
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl $0x305, %edx            # imm = 0x305
callq 0x109670
movq %r14, %rdi
movq %rbx, %rsi
movl $0x306, %edx            # imm = 0x306
callq 0x109670
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x307, %edx            # imm = 0x307
callq 0x109670
movq 0x3fbbee(%rip), %rsi    # 0x4c9498
testq %rsi, %rsi
je 0xcd8bd
leaq 0x296d30(%rip), %rdi    # 0x3645e6
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
je 0xcd99e
cmpq $0x0, 0x8(%r12)
je 0xccf76
xorl %ebx, %ebx
callq 0x125bcc
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq 0x18(%r12), %rcx
incq %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, (%r15,%rbx,8)
incq %rbx
cmpq 0x8(%r12), %rbx
jb 0xcd8e8
jmp 0xccf76
callq 0x20c86
callq 0x20e15
callq 0x20ddc
callq 0x20da3
callq 0x20d6a
movq 0x3f664e(%rip), %rax    # 0x4c3f80
movq (%rax), %rdi
leaq 0x296fb1(%rip), %rsi    # 0x3648ed
xorl %eax, %eax
callq 0x17ab0
movl $0x2, %edi
callq 0x17940
callq 0x20ec0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x20bac
callq 0x20b73
callq 0x20ef9
callq 0x20fa4
callq 0x20b3a
callq 0x20f6b
callq 0x20c4d
callq 0x20cf8
callq 0x20cbf
callq 0x20e87
callq 0x20e4e
callq 0x20f32
callq 0x20bdb
callq 0x20d31
callq 0x20c14