// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/lerils.c
// Function: generate_rule_pool
Ruleset generate_rule_pool(Instanceptr instances, int positive, int M, double p1)
{
 double **thresholds;
 int i, j, k, p, *counts, size, pos, **relevant, bestbit, bestp, bestdirection;
 Decisionconditionptr** included;
 Decisionconditionptr current;
 Decisionruleptr current_rule;
 Instanceptr tmp;
 Ruleset result;
 double prob, best_description_length, description_length;
 empty_ruleset(&result);
 size = data_size(instances);
 thresholds = safecalloc(current_dataset->featurecount, sizeof(double*), "learn_ruleset_lerils_oneclass", 4);
 counts = safecalloc(current_dataset->featurecount, sizeof(int), "learn_ruleset_lerils_oneclass", 5);
 for (i = 0; i < current_dataset->featurecount; i++)
   if (in_list(current_dataset->features[i].type, 2, INTEGER, REAL))
     thresholds[i] = possible_split_points(instances, i, &(counts[i]));
 included = (Decisionconditionptr**) safemalloc_2d(sizeof(Decisionconditionptr*), sizeof(Decisionconditionptr), M, current_dataset->featurecount, "generate_rule_pool", 10);
 relevant = (int**) safemalloc_2d(sizeof(int *), sizeof(int), M, current_dataset->featurecount, "generate_rule_pool", 11);
 for (i = 0; i < M; i++)
  {
   do{
      pos = myrand() % size;
      tmp = data_x(instances, pos);
   }while (give_classno(tmp) != positive);
   for (j = 0; j < current_dataset->featurecount; j++)
     if (current_dataset->features[j].type != CLASSDEF)
      {
       current = empty_condition();
       current->conditiontype = UNIVARIATE_CONDITION;
       current->freeparam = 1;
       current->featureindex = j;
       included[i][j] = current;
       prob = produce_random_value(0.0, 1.0);
       if (prob < 0.5)
         relevant[i][j] = YES;
       else
         relevant[i][j] = NO;
       switch (current_dataset->features[j].type)
        {
         case INTEGER:pos = split_point_lower_and_upper_limits(tmp->values[j].intvalue, thresholds[j], counts[j]);
                      current->comparison = '*';
                      current->upperlimit = thresholds[j][pos + 1];
                      current->lowerlimit = thresholds[j][pos];
                      current->datasize = pos;
                      current->value = pos + 1;
                      break;
         case    REAL:pos = split_point_lower_and_upper_limits(tmp->values[j].floatvalue, thresholds[j], counts[j]);
                      current->comparison = '*';
                      current->upperlimit = thresholds[j][pos + 1];
                      current->lowerlimit = thresholds[j][pos];
                      current->datasize = pos;
                      current->value = pos + 1;
                      break;
         case  STRING:current->comparison = '=';
                      current->value = tmp->values[j].stringindex;
                      break;
        }
      }
     else
       relevant[i][j] = NO;
   /*Random walk*/
   for (j = 0; j < 3 * (current_dataset->featurecount - 1); j++)
    {
     prob = produce_random_value(0.0, 1.0);
     if (prob < p1)
      {
       do{
         pos = myrand() % current_dataset->featurecount;
       }while (current_dataset->features[pos].type == CLASSDEF); 
       relevant[i][pos] = 1 - relevant[i][pos];
      }
     else
      {
       best_description_length = description_length_of_rule_lerils(included[i], relevant[i], instances, positive);
       bestbit = -1;
       for (k = 0; k < current_dataset->featurecount; k++)
         if (current_dataset->features[k].type != CLASSDEF)
          {
           if (current_dataset->features[k].type == STRING || relevant[i][k])
            {
             relevant[i][k] = 1 - relevant[i][k];
             if (rule_cover_instance_lerils(included[i], relevant[i], tmp))
              {
               description_length = description_length_of_rule_lerils(included[i], relevant[i], instances, positive);
               if (description_length < best_description_length)
                {
                 bestbit = k;
                 best_description_length = description_length;
                }
              }
             relevant[i][k] = 1 - relevant[i][k];
            }
           else
             if (!relevant[i][k])
              {
               relevant[i][k] = 1 - relevant[i][k];
               for (p = included[i][k]->datasize - 1; p >= 0; p--)
                {
                 included[i][k]->lowerlimit = thresholds[k][p];
                 if (rule_cover_instance_lerils(included[i], relevant[i], tmp))
                  {
                   description_length = description_length_of_rule_lerils(included[i], relevant[i], instances, positive);
                   if (description_length < best_description_length)
                    {
                     bestbit = k;
                     bestp = p;
                     bestdirection = -1;
                     best_description_length = description_length;
                    }
                  }
                }
               included[i][k]->lowerlimit = thresholds[k][included[i][k]->datasize];
               for (p = ((int)included[i][k]->value) + 1; p < counts[k]; p++)
                {
                 included[i][k]->upperlimit = thresholds[k][p];
                 if (rule_cover_instance_lerils(included[i], relevant[i], tmp))
                  {
                   description_length = description_length_of_rule_lerils(included[i], relevant[i], instances, positive);
                   if (description_length < best_description_length)
                    {
                     bestbit = k;
                     bestp = p;
                     bestdirection = +1;
                     best_description_length = description_length;
                    }
                  }
                }
               included[i][k]->upperlimit = thresholds[k][(int)included[i][k]->value];
               relevant[i][k] = 1 - relevant[i][k];
              }
          }
       if (bestbit != -1)
        {
         relevant[i][bestbit] = 1 - relevant[i][bestbit];
         if (relevant[i][bestbit] && current_dataset->features[bestbit].type != STRING)
          {
           if (bestdirection == -1)
             included[i][bestbit]->lowerlimit = thresholds[bestbit][bestp];
           else
             included[i][bestbit]->upperlimit = thresholds[bestbit][bestp];
          }
        }
      }
    }
   current_rule = empty_rule(positive);
   for (j = 0; j < current_dataset->featurecount; j++)
     if (relevant[i][j])
       add_condition(current_rule, create_copy_of_condition(included[i][j]));
   if (!rule_exists(result, current_rule))
     add_rule(&result, current_rule);
   else
    {
     free_rule(*current_rule);
     safe_free(current_rule);
    }
  }
 free_2d((void**)relevant, M);
 for (i = 0; i < M; i++)
  {
   for (j = 0; j < current_dataset->featurecount; j++)
     if (current_dataset->features[j].type != CLASSDEF)
      {
       free_condition(*(included[i][j]));
       safe_free(included[i][j]);
      }
   safe_free(included[i]);
  }
 safe_free(included);
 for (i = 0; i < current_dataset->featurecount; i++)
   if (counts[i] > 0)
     safe_free(thresholds[i]);
 safe_free(thresholds);
 safe_free(counts); 
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movsd %xmm0, 0xd0(%rsp)
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbp
movq %rdi, 0xc0(%rsp)
callq 0x7c32b
movq %rbp, %rdi
callq 0x30309
movl %eax, 0xbc(%rsp)
leaq 0x9ee52(%rip), %r14     # 0xd5870
movq (%r14), %rax
movslq 0x1bc(%rax), %rdi
leaq 0x72d33(%rip), %rbx     # 0xa9762
movl $0x8, %esi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x3a1fc
movq %rax, 0x80(%rsp)
movq (%r14), %rax
movslq 0x1bc(%rax), %rdi
movl $0x4, %esi
movq %rbx, %rdx
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, 0x98(%rsp)
movq (%r14), %rax
movl 0x1bc(%rax), %ecx
testl %ecx, %ecx
jle 0x36aeb
movl $0x18784, %r14d         # imm = 0x18784
movq 0x98(%rsp), %rbx
xorl %r15d, %r15d
movl (%rax,%r14,2), %edi
movl $0x2, %esi
xorl %edx, %edx
movl $0x2, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x36ac0
movq %rbp, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x366f0
movq 0x80(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
leaq 0x9eda6(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq 0x1bc(%rax), %rcx
addq $0x4, %rbx
addq $0x1a0, %r14            # imm = 0x1A0
cmpq %rcx, %r15
jl 0x36a8b
leaq 0x9ed85(%rip), %r14     # 0xd5870
movq %rbp, 0xa8(%rsp)
leaq 0x72c86(%rip), %r15     # 0xa9780
movl $0x8, %edi
movl $0x8, %esi
movl %r12d, %edx
movq %r15, %r8
movl $0xa, %r9d
callq 0x3a3ac
movq %rax, %rbx
movq (%r14), %rax
movl 0x1bc(%rax), %ecx
movl $0x8, %edi
movl $0x4, %esi
movl %r12d, %edx
movq %r15, %r8
movl $0xb, %r9d
callq 0x3a3ac
movq %rax, %rbp
testl %r12d, %r12d
jle 0x372c7
movl %r12d, 0xb8(%rsp)
movl %r12d, %eax
movq %rax, 0xc8(%rsp)
xorl %r12d, %r12d
movl %r13d, 0x78(%rsp)
xorl %eax, %eax
callq 0x3af20
cltd
idivl 0xbc(%rsp)
movq 0xa8(%rsp), %rdi
movl %edx, %esi
callq 0x31851
movq %rax, %r15
movq %rax, %rdi
callq 0x2f33a
cmpl %r13d, %eax
jne 0x36b63
movq (%r14), %rax
movl 0x1bc(%rax), %ecx
testl %ecx, %ecx
jle 0x36d8a
xorl %r14d, %r14d
imulq $0x340, %r14, %r13      # imm = 0x340
cmpl $0x3, 0x30f08(%rax,%r13)
jne 0x36bce
movq (%rbp,%r12,8), %rcx
movl $0x0, (%rcx,%r14,4)
movl 0x78(%rsp), %r13d
jmp 0x36d70
xorl %eax, %eax
callq 0x7c366
movq $0x1, 0x3c(%rax)
movl %r14d, (%rax)
movq (%rbx,%r12,8), %rcx
movq %rax, 0x88(%rsp)
movq %rax, (%rcx,%r14,8)
xorpd %xmm0, %xmm0
movsd 0x6e924(%rip), %xmm1    # 0xa5520
callq 0x3af6a
xorl %eax, %eax
movsd 0x6f10d(%rip), %xmm1    # 0xa5d18
ucomisd %xmm0, %xmm1
seta %al
movq (%rbp,%r12,8), %rcx
movl %eax, (%rcx,%r14,4)
leaq 0x9ec4e(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x30f08(%rax,%r13), %ecx
cmpl $0x2, %ecx
je 0x36cd6
cmpl $0x1, %ecx
movl 0x78(%rsp), %r13d
je 0x36cb4
testl %ecx, %ecx
jne 0x36d70
movq 0x80(%rsp), %rcx
movq (%rcx,%r14,8), %rcx
movq 0x98(%rsp), %rdx
movl (%rdx,%r14,4), %edi
xorl %edx, %edx
cmpl $0x3, %edi
jl 0x36d3b
movq (%r15), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%r14,8), %xmm0
decl %edi
xorl %edx, %edx
movl %edi, %esi
movl %edi, %r8d
shrl $0x1f, %r8d
addl %edi, %r8d
sarl %r8d
movslq %r8d, %rdi
movsd (%rcx,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x36c9d
movl %r8d, %edx
jmp 0x36ca0
movl %r8d, %esi
leal (%rsi,%rdx), %edi
movl %esi, %r8d
subl %edx, %r8d
cmpl $0x1, %r8d
jg 0x36c7d
jmp 0x36d3b
movq 0x88(%rsp), %rdx
movb $0x3d, 0x4(%rdx)
movq (%r15), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%r14,8), %xmm0
movsd %xmm0, 0x8(%rdx)
jmp 0x36d70
movq 0x80(%rsp), %rcx
movq (%rcx,%r14,8), %rcx
movq 0x98(%rsp), %rdx
movl (%rdx,%r14,4), %edi
xorl %edx, %edx
cmpl $0x3, %edi
movl 0x78(%rsp), %r13d
jl 0x36d3b
movq (%r15), %rdx
movsd (%rdx,%r14,8), %xmm0
decl %edi
xorl %edx, %edx
movl %edi, %esi
movl %edi, %r8d
shrl $0x1f, %r8d
addl %edi, %r8d
sarl %r8d
movslq %r8d, %rdi
movsd (%rcx,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x36d29
movl %r8d, %edx
jmp 0x36d2c
movl %r8d, %esi
leal (%rsi,%rdx), %edi
movl %esi, %r8d
subl %edx, %r8d
cmpl $0x1, %r8d
jg 0x36d09
movq 0x88(%rsp), %rdi
movb $0x2a, 0x4(%rdi)
movslq %edx, %rsi
incl %edx
movsd 0x8(%rcx,%rsi,8), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, 0x18(%rdi)
movl %esi, 0x38(%rdi)
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rdi)
incq %r14
movslq 0x1bc(%rax), %rcx
cmpq %rcx, %r14
jl 0x36ba5
leaq 0x9eae6(%rip), %r14     # 0xd5870
leal (%rcx,%rcx,2), %eax
addl $-0x3, %eax
testl %eax, %eax
jle 0x37149
xorl %edx, %edx
movl %edx, 0x7c(%rsp)
xorpd %xmm0, %xmm0
movsd 0x6e776(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd 0xd0(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x36df8
xorl %eax, %eax
callq 0x3af20
movq (%r14), %rcx
cltd
idivl 0x1bc(%rcx)
movslq %edx, %rax
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x3, 0x30f08(%rcx,%rdx)
je 0x36dbe
movq (%rbp,%r12,8), %rdx
movl $0x1, %esi
subl (%rdx,%rax,4), %esi
movl %esi, (%rdx,%rax,4)
jmp 0x3711b
movq (%rbx,%r12,8), %rdi
movq (%rbp,%r12,8), %rsi
movq 0xa8(%rsp), %rdx
movl %r13d, %ecx
callq 0x368d8
movsd %xmm0, 0x88(%rsp)
movq (%r14), %rcx
cmpl $0x0, 0x1bc(%rcx)
jle 0x3711b
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
xorl %r13d, %r13d
imulq $0x340, %r13, %rax      # imm = 0x340
movl 0x30f08(%rcx,%rax), %eax
cmpl $0x3, %eax
je 0x37096
cmpl $0x1, %eax
jne 0x36e63
movq (%rbp,%r12,8), %rsi
movl (%rsi,%r13,4), %eax
movq (%rbx,%r12,8), %rdi
jmp 0x36e74
movq (%rbp,%r12,8), %rsi
movl (%rsi,%r13,4), %eax
movq (%rbx,%r12,8), %rdi
testl %eax, %eax
je 0x36ed2
movl $0x1, %ecx
subl %eax, %ecx
movl %ecx, (%rsi,%r13,4)
movq %r15, %rdx
callq 0x3686a
testl %eax, %eax
je 0x37084
movq (%rbx,%r12,8), %rdi
movq (%rbp,%r12,8), %rsi
movq 0xa8(%rsp), %rdx
movl 0x78(%rsp), %ecx
callq 0x368d8
movsd 0x88(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x37084
movl %r13d, 0x94(%rsp)
movsd %xmm0, 0x88(%rsp)
jmp 0x37084
movl $0x1, (%rsi,%r13,4)
movq (%rdi,%r13,8), %rax
movslq 0x38(%rax), %r14
testq %r14, %r14
jle 0x36f89
movq 0x80(%rsp), %rax
movq (%rax,%r13,8), %rax
movsd -0x8(%rax,%r14,8), %xmm0
movq (%rbx,%r12,8), %rdi
movq (%rdi,%r13,8), %rax
movsd %xmm0, 0x18(%rax)
movq (%rbp,%r12,8), %rsi
movq %r15, %rdx
callq 0x3686a
testl %eax, %eax
je 0x36f6c
movq (%rbx,%r12,8), %rdi
movq (%rbp,%r12,8), %rsi
movq 0xa8(%rsp), %rdx
movl 0x78(%rsp), %ecx
callq 0x368d8
movsd 0x88(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x36f6c
leal -0x1(%r14), %eax
movl %eax, 0xb4(%rsp)
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
movl %r13d, 0x94(%rsp)
movsd %xmm0, 0x88(%rsp)
decq %r14
leaq 0x1(%r14), %rax
cmpq $0x1, %rax
ja 0x36eeb
movq (%rbx,%r12,8), %rax
movq (%rax,%r13,8), %rax
movl 0x38(%rax), %r14d
movq 0x80(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
movslq %r14d, %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, 0x18(%rax)
cvttsd2si 0x8(%rax), %edx
leal 0x1(%rdx), %esi
movq 0x98(%rsp), %rdi
cmpl (%rdi,%r13,4), %esi
jge 0x37070
movslq %edx, %r14
incq %r14
movq 0x80(%rsp), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r14,8), %xmm0
movq (%rbx,%r12,8), %rdi
movq (%rdi,%r13,8), %rax
movsd %xmm0, 0x10(%rax)
movq (%rbp,%r12,8), %rsi
movq %r15, %rdx
callq 0x3686a
testl %eax, %eax
je 0x3703f
movq (%rbx,%r12,8), %rdi
movq (%rbp,%r12,8), %rsi
movq 0xa8(%rsp), %rdx
movl 0x78(%rsp), %ecx
callq 0x368d8
movsd 0x88(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3703f
movl $0x1, 0xa4(%rsp)
movl %r13d, 0x94(%rsp)
movl %r14d, 0xb4(%rsp)
movsd %xmm0, 0x88(%rsp)
incq %r14
movq 0x98(%rsp), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r14
jl 0x36fc2
movq 0x80(%rsp), %rax
movq (%rax,%r13,8), %rcx
movq (%rbx,%r12,8), %rax
movq (%rax,%r13,8), %rax
cvttsd2si 0x8(%rax), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0x9e7ec(%rip), %r14     # 0xd5870
movq (%rbp,%r12,8), %rax
movl $0x1, %ecx
subl (%rax,%r13,4), %ecx
movl %ecx, (%rax,%r13,4)
incq %r13
movq (%r14), %rcx
movslq 0x1bc(%rcx), %rax
cmpq %rax, %r13
jl 0x36e38
movl 0x94(%rsp), %eax
cmpl $-0x1, %eax
je 0x37116
movq (%rbp,%r12,8), %rdx
cltq
movl (%rdx,%rax,4), %esi
leal -0x1(%rsi), %edi
negl %edi
movl %edi, (%rdx,%rax,4)
decl %esi
movl 0x78(%rsp), %r13d
je 0x3711b
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rdx)
je 0x3711b
movq 0x80(%rsp), %rdx
movq (%rdx,%rax,8), %rdx
movslq 0xb4(%rsp), %rsi
movsd (%rdx,%rsi,8), %xmm0
movq (%rbx,%r12,8), %rdx
movq (%rdx,%rax,8), %rax
cmpl $-0x1, 0xa4(%rsp)
je 0x37137
movsd %xmm0, 0x10(%rax)
jmp 0x3711b
movl 0x78(%rsp), %r13d
movl 0x7c(%rsp), %edx
incl %edx
movl 0x1bc(%rcx), %eax
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
cmpl %eax, %edx
jl 0x36d9a
jmp 0x37149
movsd %xmm0, 0x18(%rax)
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
jmp 0x3711b
movl %r13d, %edi
callq 0x7bfd8
movq %rax, %r15
movq (%r14), %rax
cmpl $0x0, 0x1bc(%rax)
jle 0x371a0
xorl %r14d, %r14d
movq (%rbp,%r12,8), %rcx
cmpl $0x0, (%rcx,%r14,4)
je 0x37191
movq (%rbx,%r12,8), %rax
movq (%rax,%r14,8), %rdi
callq 0x7bd48
movq %r15, %rdi
movq %rax, %rsi
callq 0x7c040
leaq 0x9e6e2(%rip), %rax     # 0xd5870
movq (%rax), %rax
incq %r14
movslq 0x1bc(%rax), %rcx
cmpq %rcx, %r14
jl 0x37163
movq 0xc0(%rsp), %r14
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movupd (%r14), %xmm0
movupd 0x10(%r14), %xmm1
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x9faf9
testl %eax, %eax
je 0x3720b
movq 0x30(%r15), %rax
movq %rax, 0x30(%rsp)
movupd (%r15), %xmm0
movupd 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x7c251
movq %r15, %rdi
callq 0x3a180
jmp 0x37216
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c9c6
incq %r12
cmpq 0xc8(%rsp), %r12
leaq 0x9e648(%rip), %r14     # 0xd5870
jne 0x36b63
movq %rbp, %rdi
movl 0xb8(%rsp), %ebp
movl %ebp, %esi
callq 0x3a14b
testl %ebp, %ebp
jle 0x372d2
xorl %r14d, %r14d
leaq 0x9e61f(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x0, 0x1bc(%rax)
jle 0x372af
movl $0x61e1, %r15d          # imm = 0x61E1
xorl %r12d, %r12d
cmpl $0x3, (%rax,%r15,8)
je 0x3729c
movq (%rbx,%r14,8), %rax
movq (%rax,%r12,8), %rsi
movl $0xe, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x7c1f4
movq (%rbx,%r14,8), %rax
movq (%rax,%r12,8), %rdi
callq 0x3a180
leaq 0x9e5d7(%rip), %rax     # 0xd5870
movq (%rax), %rax
incq %r12
movslq 0x1bc(%rax), %rcx
addq $0x68, %r15
cmpq %rcx, %r12
jl 0x37266
movq (%rbx,%r14,8), %rdi
callq 0x3a180
incq %r14
cmpq 0xc8(%rsp), %r14
jne 0x3724a
jmp 0x372d2
movq %rbp, %rdi
movl %r12d, %esi
callq 0x3a14b
movq %rbx, %rdi
callq 0x3a180
leaq 0x9e58f(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x0, 0x1bc(%rax)
movq 0xc0(%rsp), %r14
jle 0x3732f
xorl %ebx, %ebx
movq 0x98(%rsp), %rcx
cmpl $0x0, (%rcx,%rbx,4)
jle 0x37320
movq 0x80(%rsp), %rax
movq (%rax,%rbx,8), %rdi
callq 0x3a180
leaq 0x9e553(%rip), %rax     # 0xd5870
movq (%rax), %rax
incq %rbx
movslq 0x1bc(%rax), %rcx
cmpq %rcx, %rbx
jl 0x372f7
movq 0x80(%rsp), %rdi
callq 0x3a180
movq 0x98(%rsp), %rdi
callq 0x3a180
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq