LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/softblockmodel.h
// Function: findSoftCollisionRateAndDensity
sim_stats_t findSoftCollisionRateAndDensity(size_t HowManyKeys, size_t bitbudget,
                             size_t BlockSizeInBits, size_t fold,
                             bool verbose) {
  softmodel_t m;
  m.NumberOfBlocks = bitbudget / BlockSizeInBits;
  m.BlockSizeInBits = BlockSizeInBits;
  size_t howmanytests = 100000;
  bitset_t *b = bitset_create_with_capacity(bitbudget);
  m.FoldCount = fold;
  // we take the averge of several attempts
  sim_stats_t s; 
  s.collision_rate = 0;
  s.density = 0;
  size_t attempts = HowManyKeys < 10000000 ? 5 : 1;
  for (int i = 0; i < attempts; i++) {
    sim_stats_t ts = simulate_soft(HowManyKeys, m, howmanytests, b);
    s.density += ts.density;
    s.collision_rate += ts.collision_rate;
  }
  s.collision_rate /= attempts;
  s.density /= attempts;
  bitset_free(b);
  return s;
}

// Assembly:
subq $0x98, %rsp
movb %r8b, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0x78(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x70(%rsp)
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq $0x186a0, 0x40(%rsp)    # imm = 0x186A0
movq 0x78(%rsp), %rdi
callq 0x34a0
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
movq 0x80(%rsp), %rdx
movl $0x1, %eax
movl $0x5, %ecx
cmpq $0x989680, %rdx         # imm = 0x989680
cmovbl %ecx, %eax
cltq
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x2f0a
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2720
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x88(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2e79
movq 0x30(%rsp), %xmm3
movaps 0x30f9(%rip), %xmm2     # 0x6010
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movapd 0x30fd(%rip), %xmm0     # 0x6020
subpd %xmm0, %xmm3
movaps %xmm3, %xmm1
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
addsd %xmm1, %xmm3
movsd 0x88(%rsp), %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x88(%rsp)
movq 0x30(%rsp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x90(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x90(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3b00
movsd 0x88(%rsp), %xmm0
movsd 0x90(%rsp), %xmm1
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/softblockmodel.h
// Function: assessFold
void assessFold(size_t HowManyKeys, size_t BlockSizeInBits,
                          bool verbose) {
  for (size_t bitsperkey = 8; bitsperkey <= 10; bitsperkey += 1) {
    size_t bitbudget = bitsperkey * HowManyKeys;
    sim_stats_t beststats;
    size_t bestfold = findBestFold(HowManyKeys, bitbudget, BlockSizeInBits,
                                       &beststats, verbose);
    printf("bits per key %3zu best fold = %zu,  density = %0.0f %%, collision rate = "
           "%0.3f %% \n",
           bitsperkey, bestfold, beststats.density * 100, beststats.collision_rate * 100);
  }
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq $0x8, 0x28(%rsp)
cmpq $0xa, 0x28(%rsp)
ja 0x3046
movq 0x28(%rsp), %rax
imulq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
movb 0x37(%rsp), %al
leaq 0x10(%rsp), %rcx
andb $0x1, %al
movzbl %al, %r8d
callq 0x2b80
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdx
movsd 0x303f(%rip), %xmm0     # 0x6050
mulsd 0x18(%rsp), %xmm0
movsd 0x3031(%rip), %xmm1     # 0x6050
mulsd 0x10(%rsp), %xmm1
leaq 0x32ad(%rip), %rdi      # 0x62d9
movb $0x2, %al
callq 0x1060
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2fbf
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/blockmodel.c
// Function: main
int main() {
  printf("bits per key indicates storage (bits used per key): smaller is "
         "better\n");
  printf("best bits per bucket indicates the number of bits to check per key: "
         "smaller is better\n");
  printf("collision rate is the false negative rate: smaller is better\n");
  printf("In the 'lane' model you have one bit set per lane.\n");
  printf("\n");

  compute(1000);
  printf("==========\n\n");

  compute(1000000);
  printf("==========\n\n");

  compute(10000000);
  printf("==========\n\n");

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
leaq 0x3138(%rip), %rdi      # 0x6408
movb $0x0, %al
callq 0x1060
leaq 0x3171(%rip), %rdi      # 0x644f
movb $0x0, %al
callq 0x1060
leaq 0x31ba(%rip), %rdi      # 0x64a6
movb $0x0, %al
callq 0x1060
leaq 0x31ea(%rip), %rdi      # 0x64e4
movb $0x0, %al
callq 0x1060
leaq 0x321b(%rip), %rdi      # 0x6523
movb $0x0, %al
callq 0x1060
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x3050
leaq 0x31f8(%rip), %rdi      # 0x6518
movb $0x0, %al
callq 0x1060
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x3050
leaq 0x31e0(%rip), %rdi      # 0x6518
movb $0x0, %al
callq 0x1060
movl $0x989680, %edi         # imm = 0x989680
callq 0x3050
leaq 0x31c8(%rip), %rdi      # 0x6518
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.h
// Function: bitset_grow
static inline bool bitset_grow( bitset_t *bitset,  size_t newarraysize ) {
  if (bitset->capacity < newarraysize) {
    uint64_t *newarray;
    bitset->capacity = newarraysize * 2;
    if ((newarray = (uint64_t *) realloc(bitset->array, sizeof(uint64_t) * bitset->capacity)) == NULL) {
      free(bitset->array);
      return false;
    }
    bitset->array = newarray;
  }
  memset(bitset->array + bitset->arraysize ,0,sizeof(uint64_t) * (newarraysize - bitset->arraysize));
  bitset->arraysize = newarraysize;
  return true; // success!
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rsp), %rax
jae 0x33d5
movq 0x10(%rsp), %rcx
shlq %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10b0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x33c8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movb $0x0, 0x27(%rsp)
jmp 0x3419
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
subq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1070
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_create
bitset_t *bitset_create() {
  bitset_t *bitset = NULL;
  /* Allocate the bitset itself. */
  if( ( bitset = (bitset_t*) malloc( sizeof( bitset_t ) ) ) == NULL ) {
      return NULL;
  }
  bitset->array = NULL;
  bitset->arraysize = 0;
  bitset->capacity = 0;
  return bitset;
}

// Assembly:
subq $0x18, %rsp
movq $0x0, 0x8(%rsp)
movl $0x18, %edi
callq 0x10a0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x345d
movq $0x0, 0x10(%rsp)
jmp 0x348d
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_create_with_capacity
bitset_t *bitset_create_with_capacity( size_t size ) {
  bitset_t *bitset = NULL;
  /* Allocate the bitset itself. */
  if( ( bitset = (bitset_t*) malloc( sizeof( bitset_t ) ) ) == NULL ) {
      return NULL;
  }
  bitset->arraysize = (size + sizeof(uint64_t) * 8 - 1) / (sizeof(uint64_t) * 8);
  bitset->capacity = bitset->arraysize;
  if ((bitset->array = (uint64_t *) malloc(sizeof(uint64_t) * bitset->arraysize)) == NULL) {
    free( bitset);
    return NULL;
  }
  memset(bitset->array,0,sizeof(uint64_t) * bitset->arraysize);
  return bitset;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x18, %edi
callq 0x10a0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x34d0
movq $0x0, 0x10(%rsp)
jmp 0x354e
movq 0x8(%rsp), %rcx
addq $0x40, %rcx
subq $0x1, %rcx
shrq $0x6, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x10a0
movq (%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x352b
movq (%rsp), %rdi
callq 0x1030
movq $0x0, 0x10(%rsp)
jmp 0x354e
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1070
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_copy
bitset_t *bitset_copy( const bitset_t * bitset ) {
  bitset_t *copy = NULL;
  /* Allocate the bitset itself. */
  if( ( copy = (bitset_t*) malloc( sizeof( bitset_t ) ) ) == NULL ) {
      return NULL;
  }
  memcpy(copy,bitset,sizeof(bitset_t));
  copy->capacity = copy->arraysize;
  if ((copy->array = (uint64_t *) malloc(sizeof(uint64_t) * bitset->arraysize)) == NULL) {
    free(copy);
    return NULL;
  }
  memcpy(copy->array,bitset->array,sizeof(uint64_t) * bitset->arraysize);
  return copy;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x18, %edi
callq 0x10a0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x3593
movq $0x0, 0x10(%rsp)
jmp 0x361f
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x10a0
movq (%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x35f5
movq (%rsp), %rdi
callq 0x1030
movq $0x0, 0x10(%rsp)
jmp 0x361f
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x1090
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_resize
bool bitset_resize( bitset_t *bitset,  size_t newarraysize, bool padwithzeroes ) {
  size_t smallest = newarraysize < bitset->arraysize ? newarraysize : bitset->arraysize;
  if (bitset->capacity < newarraysize) {
    uint64_t *newarray;
    bitset->capacity = newarraysize * 2;
    if ((newarray = (uint64_t *) realloc(bitset->array, sizeof(uint64_t) * bitset->capacity)) == NULL) {
      free(bitset->array);
      return false;
    }
    bitset->array = newarray;
  }
  if (padwithzeroes && (newarraysize > smallest))
    memset(bitset->array + smallest,0,sizeof(uint64_t) * (newarraysize - smallest));
  bitset->arraysize = newarraysize;
  return true; // success!
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x38a1
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
jmp 0x38ae
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x20(%rsp), %rax
jae 0x391e
movq 0x20(%rsp), %rcx
shlq %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10b0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x3911
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movb $0x0, 0x37(%rsp)
jmp 0x396d
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
testb $0x1, 0x1f(%rsp)
je 0x395a
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x395a
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rdx
subq 0x10(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1070
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_shift_right
void bitset_shift_right(bitset_t *bitset, size_t s) {
  size_t extra_words = s / 64;
  int inword_shift = s % 64;
  size_t as = bitset->arraysize;
  if(inword_shift == 0) {
    // could be done with a memmove
    for(size_t i = 0 ; i < as - extra_words; i++) {
      bitset->array[i] = bitset->array[i + extra_words];
    }
    bitset_resize(bitset,as - extra_words, false);

  } else {
    for(size_t i = 0 ; i + extra_words + 1 < as ; i++) {
      bitset->array[i] = (bitset->array[i + extra_words] >> inword_shift)
      | (bitset->array[i + extra_words + 1] << (64 - inword_shift));
    }
    bitset->array[as - extra_words - 1] = (bitset->array[as - 1] >> inword_shift);
    bitset_resize(bitset,as - extra_words , false);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
shrq $0x6, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
andq $0x3f, %rax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x3a2d
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x3a12
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
addq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x39c7
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
subq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x3870
jmp 0x3afa
movq $0x0, (%rsp)
movq (%rsp), %rax
addq 0x20(%rsp), %rax
addq $0x1, %rax
cmpq 0x10(%rsp), %rax
jae 0x3aac
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
addq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movl 0x1c(%rsp), %eax
movl %eax, %ecx
shrq %cl, %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
addq 0x20(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movl $0x40, %ecx
subl 0x1c(%rsp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
orq %rax, %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x3a35
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movl 0x1c(%rsp), %eax
movl %eax, %ecx
shrq %cl, %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
subq 0x20(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
subq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x3870
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_union
bool bitset_inplace_union(bitset_t * restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  for(size_t k = 0 ; k < minlength; ++k) {
    b1->array[k] |= b2->array[k];
  }
  if(b2->arraysize > b1->arraysize) {
     size_t oldsize = b1->arraysize;
     if(!bitset_resize( b1, b2->arraysize, false)) return false;
     memcpy(b1->array + oldsize, b2->array + oldsize, (b2->arraysize - oldsize) * sizeof(uint64_t));
  }
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4201
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x420e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x4262
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4220
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x42e3
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x3870
testb $0x1, %al
jne 0x42a4
movb $0x0, 0x37(%rsp)
jmp 0x42e8
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdx
subq 0x8(%rsp), %rdx
shlq $0x3, %rdx
callq 0x1090
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_minimum
size_t bitset_minimum(const bitset_t *bitset) {
  for(size_t k = 0; k < bitset->arraysize; k++) {
    uint64_t w = bitset->array[k];
    if ( w != 0 ) {
      return __builtin_ctzll(w) + k * 64;
    }
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x436d
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x435b
movq -0x20(%rsp), %rax
tzcntq %rax, %rax
cltq
movq -0x18(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x4376
jmp 0x435d
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x430e
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_maximum
size_t bitset_maximum(const bitset_t *bitset) {
  for(size_t k = bitset->arraysize ; k > 0 ; k--) {
    uint64_t w = bitset->array[k - 1];
    if ( w != 0 ) {
      return  63 - __builtin_clzll(w) + (k - 1) * 64;
    }
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jbe 0x43fe
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x43ec
movq -0x20(%rsp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
movl %eax, %ecx
movl $0x3f, %eax
subl %ecx, %eax
cltq
movq -0x18(%rsp), %rcx
subq $0x1, %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x4407
jmp 0x43ee
movq -0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x4393
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_intersection
void bitset_inplace_intersection(bitset_t * restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  for( ; k < minlength; ++k) {
    b1->array[k] &= b2->array[k];
  }
  for(; k < b1->arraysize; ++k) {
    b1->array[k] = 0; // memset could, maybe, be a tiny bit faster
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4cfe
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x4d0c
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x4d61
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x4d1f
jmp 0x4d63
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4d98
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x4d63
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_intersection_count
size_t bitset_intersection_count(const bitset_t * restrict b1, const bitset_t * restrict b2) {
  size_t answer = 0;
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  for(size_t k = 0 ; k < minlength; ++k) {
    answer += __builtin_popcountll ( b1->array[k] & b2->array[k]);
  }
  return answer;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4dd7
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x4de5
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x4ea2
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rdx
andq (%rax,%rdx,8), %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
cltq
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x4df8
movq -0x18(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_difference
void bitset_inplace_difference(bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  for( ; k < minlength; ++k) {
    b1->array[k] &= ~ (b2->array[k]);
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4ede
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x4eec
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x4f45
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
xorq $-0x1, %rdx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x4eff
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_difference_count
size_t  bitset_difference_count(const bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  size_t answer = 0;
  for( ; k < minlength; ++k) {
    answer += __builtin_popcountll (b1->array[k] & ~ (b2->array[k]));
  }
  for( ; k < b1->arraysize ; ++k) {
    answer += __builtin_popcountll (b1->array[k]);
  }
  return answer;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4f7e
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x4f8c
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x5059
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rdx
movq (%rax,%rdx,8), %rax
xorq $-0x1, %rax
andq %rax, %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
cltq
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x4fa8
jmp 0x505b
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x50f8
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
cltq
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x505b
movq -0x28(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_symmetric_difference
bool bitset_inplace_symmetric_difference(bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  for( ; k < minlength; ++k) {
    b1->array[k] ^= b2->array[k];
  }
  if(b2->arraysize > b1->arraysize) {
     size_t oldsize = b1->arraysize;
     if(!bitset_resize( b1, b2->arraysize, false)) return false;
     memcpy(b1->array + oldsize, b2->array + oldsize, (b2->arraysize - oldsize) * sizeof(uint64_t));
  }
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x5131
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x513e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x5192
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x5150
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x5213
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x3870
testb $0x1, %al
jne 0x51d4
movb $0x0, 0x37(%rsp)
jmp 0x5218
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdx
subq 0x8(%rsp), %rdx
shlq $0x3, %rdx
callq 0x1090
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_trim
bool bitset_trim(bitset_t * bitset) {
  size_t newsize = bitset->arraysize;
  while(newsize > 0) {
    if(bitset->array[newsize - 1] == 0)
        newsize -= 1;
    else
        break;
  }
  if(bitset->capacity == newsize) return true; // nothing to do
  bitset->capacity = newsize;
  bitset->arraysize = newsize;
  uint64_t *newarray;
  if ((newarray = (uint64_t *) realloc(bitset->array, sizeof(uint64_t) * bitset->capacity)) == NULL) {
      free(bitset->array);
      return false;
  }
  bitset->array = newarray;
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x54eb
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x54e7
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x54e9
jmp 0x54eb
jmp 0x54b7
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x5502
movb $0x1, 0x27(%rsp)
jmp 0x5569
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10b0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x5557
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movb $0x0, 0x27(%rsp)
jmp 0x5569
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/paeq128/aesni/encrypt.cpp
// Function: gmul_o(unsigned char, unsigned char)
unsigned char gmul_o(unsigned char a, unsigned char b) {
	unsigned char p = 0;
	unsigned char counter;
	unsigned char hi_bit_set;
	for (counter = 0; counter < 8; counter++) {
		if ((b & 1) == 1)
			p ^= a;
		hi_bit_set = (a & 0x80);
		a <<= 1;
		if (hi_bit_set == 0x80)
			a ^= 0x1b;
		b >>= 1;
	}
	return p;
}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rsp)
movb %al, -0x2(%rsp)
movb $0x0, -0x3(%rsp)
movb $0x0, -0x4(%rsp)
movzbl -0x4(%rsp), %eax
cmpl $0x8, %eax
jge 0x2837
movzbl -0x2(%rsp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x27ef
movzbl -0x1(%rsp), %ecx
movzbl -0x3(%rsp), %eax
xorl %ecx, %eax
movb %al, -0x3(%rsp)
movzbl -0x1(%rsp), %eax
andl $0x80, %eax
movb %al, -0x5(%rsp)
movzbl -0x1(%rsp), %eax
shll %eax
movb %al, -0x1(%rsp)
movzbl -0x5(%rsp), %eax
cmpl $0x80, %eax
jne 0x2820
movzbl -0x1(%rsp), %eax
xorl $0x1b, %eax
movb %al, -0x1(%rsp)
movzbl -0x2(%rsp), %eax
sarl %eax
movb %al, -0x2(%rsp)
movb -0x4(%rsp), %al
addb $0x1, %al
movb %al, -0x4(%rsp)
jmp 0x27c8
movb -0x3(%rsp), %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/infoitem.cpp
// Function: InfoItem::InfoItem(smooth::String const&, smooth::String const&)
InfoItem::InfoItem(const String &iName, const String &iValue) : ListEntry(NIL)
{
	type	= classID;

	name	= iName;
	value	= iValue;

	UpdateText();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
callq 0x8490
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x8090
jmp 0x8baa
leaq -0x30(%rbp), %rdi
callq 0x8990
movq -0x50(%rbp), %rdi
leaq 0x1b442(%rip), %rax     # 0x24000
movq %rax, (%rdi)
addq $0x630, %rdi            # imm = 0x630
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
callq 0x8490
jmp 0x8bd5
movq -0x50(%rbp), %rdi
addq $0x648, %rdi            # imm = 0x648
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
callq 0x8490
jmp 0x8bed
movq -0x50(%rbp), %rdi
movswl 0x1c8ea(%rip), %esi     # 0x254e2
addq $0x20, %rdi
callq 0x8e90
jmp 0x8c03
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x630, %rdi            # imm = 0x630
callq 0x8560
jmp 0x8c19
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x648, %rdi            # imm = 0x648
callq 0x8560
jmp 0x8c2f
movq -0x50(%rbp), %rdi
callq 0x8cb0
jmp 0x8c3a
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8990
jmp 0x8c9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8c91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8c88
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8990
movq -0x58(%rbp), %rdi
callq 0x8990
movq -0x50(%rbp), %rdi
callq 0x8970
movq -0x38(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::GUI::ListEntry*>::Disconnect<Section, Section, void>(void (Section::*)(smooth::GUI::ListEntry*), Section*)
Int Disconnect(slotReturnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL) return Error();

				SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>	 slot(proc, inst);

				for (Int i = slotsN->Length() - 1; i >= 0; i--)
				{
					if ((*((SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))) == slot)
					{
						RemoveNthN(i);

						break;
					}
				}

				return Success();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq %rdi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xb7c5
leaq -0x48(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9230
leaq -0x48(%rbp), %rdi
callq 0x8ef0
movl %eax, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9260
jmp 0xb8c3
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rdx, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0xe560
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb410
subl $0x1, %eax
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jl 0xb891
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x7c(%rbp), %esi
callq 0xbef0
movq %rax, -0xb0(%rbp)
jmp 0xb826
movq -0xb0(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x68(%rbp), %rsi
callq *%rax
movb %al, -0xb1(%rbp)
jmp 0xb845
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xb851
jmp 0xb881
movq -0xa8(%rbp), %rdi
movl -0x7c(%rbp), %esi
callq 0xbd90
jmp 0xb862
jmp 0xb891
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xe5d0
jmp 0xb8cf
jmp 0xb883
movl -0x7c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0xb800
leaq -0xa0(%rbp), %rdi
callq 0x8eb0
jmp 0xb89f
leaq -0xa0(%rbp), %rdi
callq 0x8ef0
movl %eax, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x8f10
leaq -0x68(%rbp), %rdi
callq 0xe5d0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x8290
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::GUI::ListEntry*>::Connect<Section, Section, void>(void (Section::*)(smooth::GUI::ListEntry*), Section*)
Int Connect(slotReturnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc, inst));

				return Success();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xb96b
movl $0x58, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0xe7a0
jmp 0xb935
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x82b0
jmp 0xb96b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x58, %esi
callq 0x80a0
jmp 0xba13
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x88(%rbp)
movl $0x20, %edi
callq 0x8540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xe560
jmp 0xb9b1
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0xe7e0
leaq -0x68(%rbp), %rdi
callq 0x8eb0
leaq -0x68(%rbp), %rdi
callq 0x8ef0
movl %eax, -0x8c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8f10
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x20, %esi
callq 0x80a0
movq -0x38(%rbp), %rdi
callq 0x8290
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::Emit(smooth::GUI::ListEntry*) const
Void Emit(SIGNALS_ARGUMENT_PARAMETER_LIST) const
			{
				if (slotsN == NIL && slots0 == NIL) return;

				ProtectParent();

				for (Int i = 0; slotsN != NIL && i < slotsN->Length(); i++) ((SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))->Emit(SIGNALS_ARGUMENT_PARAMETERS);
				for (Int j = 0; slots0 != NIL && j < slots0->Length(); j++) ((SlotBase0<Void> *) slots0->GetNth(j))->Emit();

				UnprotectParent();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xbacf
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xbacf
jmp 0xbbad
movq -0x20(%rbp), %rdi
callq 0xf300
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x21(%rbp)
je 0xbb0f
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0xb410
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xbb18
jmp 0xbb40
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xbef0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbadf
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x29(%rbp)
je 0xbb77
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0xb410
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xbb80
jmp 0xbba4
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbef0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbb47
movq -0x20(%rbp), %rdi
callq 0xf330
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::RemoveNthN(int)
Void RemoveNthN(Int n)
			{
				if (slotsN == NIL)	   return;
				if (slotsN->Length() <= n) return;

				delete (SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(n);

				slotsN->RemoveNth(n);

				if (slotsN->Length() == 0)
				{
					delete slotsN;

					slotsN = NIL;
				}
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xbdb3
jmp 0xbe39
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb410
cmpl -0xc(%rbp), %eax
jg 0xbdc7
jmp 0xbe39
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xbef0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbdee
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb410
cmpl $0x0, %eax
jne 0xbe39
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbe2d
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::RemoveNth0(int)
Void RemoveNth0(Int n)
			{
				if (slots0 == NIL)	   return;
				if (slots0->Length() <= n) return;

				delete (SlotBase0<Void> *) slots0->GetNth(n);

				slots0->RemoveNth(n);

				if (slots0->Length() == 0)
				{
					delete slots0;

					slots0 = NIL;
				}
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0xbe63
jmp 0xbee9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb410
cmpl -0xc(%rbp), %eax
jg 0xbe77
jmp 0xbee9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xbef0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbe9e
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb410
cmpl $0x0, %eax
jne 0xbee9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbedd
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<void*>::GetNth(int) const
const s &GetNth(Int n) const
			{
				ReadLock	 lock(*this);

				if (nOfEntries > n && n >= 0)
				{
					const s	&entry = entries[n]->value;

					lastAccessedEntry = n;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbfd0
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xbfa2
cmpl $0x0, -0x14(%rbp)
jl 0xbfa2
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movl -0x14(%rbp), %esi
callq 0xc000
movq %rax, -0x48(%rbp)
jmp 0xbf68
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xbfb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc030
jmp 0xbfc7
leaq 0x1955f(%rip), %rax     # 0x25508
movq %rax, -0x8(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc030
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8290
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::MoveNth(int, int)
Bool MoveNth(Int n, Int m)
			{
				WriteLock	 lock(*this);

				if (nOfEntries <= n || n < 0 ||
				    nOfEntries <= m || m < 0) return False;

				ArrayEntry
	*backupEntry = entries[n];

				if (m < n) memmove(entries + m + 1, entries + m, (n - m) * sizeof(ArrayEntry
 *));
				else	   memmove(entries + n, entries + n + 1, (m - n) * sizeof(ArrayEntry
 *));

				entries[m] = backupEntry;

				return IndexArray::MoveNth(n, m);
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc740
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xc1ba
cmpl $0x0, -0x14(%rbp)
jl 0xc1ba
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0xc1ba
cmpl $0x0, -0x18(%rbp)
jge 0xc1ca
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xc328
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movl -0x14(%rbp), %esi
callq 0xc770
movq %rax, -0x50(%rbp)
jmp 0xc1e0
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc26b
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0xc7a0
movq %rax, -0x58(%rbp)
jmp 0xc206
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movslq -0x18(%rbp), %rcx
leaq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
addq $0x40, %rdi
callq 0xc7a0
movq %rax, -0x60(%rbp)
jmp 0xc22a
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x80e0
jmp 0xc2ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc7e0
jmp 0xc33f
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0xc7a0
movq %rax, -0x70(%rbp)
jmp 0xc27e
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
addq $0x40, %rdi
callq 0xc7a0
movq %rax, -0x78(%rbp)
jmp 0xc2a1
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x80e0
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x40, %rdi
movl -0x18(%rbp), %esi
callq 0xc770
movq %rax, -0x88(%rbp)
jmp 0xc2ee
movq -0x48(%rbp), %rdi
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x86e0
movb %al, -0x91(%rbp)
jmp 0xc316
movb -0x91(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc7e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8290
nopl (%rax,%rax)