LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::indent(option::PrintUsageImplementation::IStringWriter&, int&, int)
static void indent(IStringWriter& write, int& x, int want_x)
  {
    int indent = want_x - x;
    if (indent < 0)
    {
      write("\n", 1);
      indent = want_x;
    }

    if (indent > 0)
    {
      char space = ' ';
      for (int i = 0; i < indent; ++i)
        write(&space, 1);
      x = want_x;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x8e50
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
leaq 0x6525(%rip), %rsi      # 0xf368
movl $0x1, %edx
callq *(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x8e8f
movb $0x20, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x8e86
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq *(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8e61
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::restartRow()
void restartRow()
    {
      ptr = rowstart;
      col = -1;
      len = 0;
      screenlen = 0;
      max_line_in_block = 0;
      line_in_block = 0;
      target_line_in_block = 0;
      hit_target_line = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rax)
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x24(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movb $0x1, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LineWrapper::flush(option::PrintUsageImplementation::IStringWriter&)
void flush(IStringWriter& write)
    {
      if (buf_empty())
        return;
      int _ = 0;
      indent(write, _, x);
      wrote_something = false;
      while (!buf_empty())
        write_one_line(write);
      write("\n", 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x95f0
testb $0x1, %al
jne 0x9193
jmp 0x9195
jmp 0x91f3
movq -0x20(%rbp), %rax
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl 0xc0(%rax), %edx
leaq -0x14(%rbp), %rsi
callq 0x8e10
movq -0x20(%rbp), %rax
movb $0x0, 0xd0(%rax)
movq -0x20(%rbp), %rdi
callq 0x95f0
xorb $-0x1, %al
testb $0x1, %al
jne 0x91cf
jmp 0x91de
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
jmp 0x91be
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
leaq 0x617c(%rip), %rsi      # 0xf368
movl $0x1, %edx
callq *(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::isWideChar(unsigned int)
static bool isWideChar(unsigned ch)
  {
    if (ch == 0x303F)
      return false;

    return ((0x1100 <= ch && ch <= 0x115F) || (0x2329 <= ch && ch <= 0x232A) || (0x2E80 <= ch && ch <= 0xA4C6)
        || (0xA960 <= ch && ch <= 0xA97C) || (0xAC00 <= ch && ch <= 0xD7FB) || (0xF900 <= ch && ch <= 0xFAFF)
        || (0xFE10 <= ch && ch <= 0xFE6B) || (0xFF01 <= ch && ch <= 0xFF60) || (0xFFE0 <= ch && ch <= 0xFFE6)
        || (0x1B000 <= ch));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x303f, -0x8(%rbp)     # imm = 0x303F
jne 0x9389
movb $0x0, -0x1(%rbp)
jmp 0x9487
movl $0x1100, %eax           # imm = 0x1100
cmpl -0x8(%rbp), %eax
ja 0x93a5
movb $0x1, %al
cmpl $0x115f, -0x8(%rbp)     # imm = 0x115F
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0x2329, %eax           # imm = 0x2329
cmpl -0x8(%rbp), %eax
ja 0x93c1
movb $0x1, %al
cmpl $0x232a, -0x8(%rbp)     # imm = 0x232A
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0x2e80, %eax           # imm = 0x2E80
cmpl -0x8(%rbp), %eax
ja 0x93dd
movb $0x1, %al
cmpl $0xa4c6, -0x8(%rbp)     # imm = 0xA4C6
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0xa960, %eax           # imm = 0xA960
cmpl -0x8(%rbp), %eax
ja 0x93f9
movb $0x1, %al
cmpl $0xa97c, -0x8(%rbp)     # imm = 0xA97C
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0xac00, %eax           # imm = 0xAC00
cmpl -0x8(%rbp), %eax
ja 0x9411
movb $0x1, %al
cmpl $0xd7fb, -0x8(%rbp)     # imm = 0xD7FB
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0xf900, %eax           # imm = 0xF900
cmpl -0x8(%rbp), %eax
ja 0x9429
movb $0x1, %al
cmpl $0xfaff, -0x8(%rbp)     # imm = 0xFAFF
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0xfe10, %eax           # imm = 0xFE10
cmpl -0x8(%rbp), %eax
ja 0x9441
movb $0x1, %al
cmpl $0xfe6b, -0x8(%rbp)     # imm = 0xFE6B
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0xff01, %eax           # imm = 0xFF01
cmpl -0x8(%rbp), %eax
ja 0x9459
movb $0x1, %al
cmpl $0xff60, -0x8(%rbp)     # imm = 0xFF60
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0xffe0, %eax           # imm = 0xFFE0
cmpl -0x8(%rbp), %eax
ja 0x9471
movb $0x1, %al
cmpl $0xffe6, -0x8(%rbp)     # imm = 0xFFE6
movb %al, -0x9(%rbp)
jbe 0x947f
movl $0x1b000, %eax          # imm = 0x1B000
cmpl -0x8(%rbp), %eax
setbe %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LineWrapper::write_one_line(option::PrintUsageImplementation::IStringWriter&)
void write_one_line(IStringWriter& write)
    {
      if (wrote_something) // if we already wrote something, we need to start a new line
      {
        write("\n", 1);
        int _ = 0;
        indent(write, _, x);
      }

      if (!buf_empty())
      {
        buf_next();
        write(datbuf[tail], lenbuf[tail]);
      }

      wrote_something = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xd0(%rax)
je 0x9534
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
leaq 0x5e59(%rip), %rsi      # 0xf368
movl $0x1, %edx
callq *(%rax)
movq -0x20(%rbp), %rax
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl 0xc0(%rax), %edx
leaq -0x14(%rbp), %rsi
callq 0x8e10
movq -0x20(%rbp), %rdi
callq 0x95f0
testb $0x1, %al
jne 0x956d
movq -0x20(%rbp), %rdi
callq 0x9620
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq 0xcc(%rax), %rcx
movq 0x40(%rax,%rcx,8), %rsi
movslq 0xcc(%rax), %rcx
movl (%rax,%rcx,4), %edx
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0xd0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::getCount(unsigned long, unsigned int)
uint32_t CountsTable::getCount(uint64_t kmer, uint sample_id) {
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts = tags_counts.find(kmer);
  // If the tag is already in the hash, we set the count for this->sample
  if(it_counts != tags_counts.end()) {
    return it_counts->second[sample_id];
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xd030
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xcf80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcf50
testb $0x1, %al
jne 0xc908
jmp 0xc920
leaq -0x28(%rbp), %rdi
callq 0xcfb0
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xc927
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::setCount(unsigned long, unsigned int, unsigned int)
void CountsTable::setCount(uint64_t kmer, uint sample_id, uint value) {
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts = tags_counts.find(kmer);
  // If the tag is already in the hash, we set the count for this->sample
  if(it_counts != tags_counts.end()) {
    it_counts->second[sample_id] = value;
  // Otherwise we create a new entry
  } else {
    uint32_t * tag_counts = new uint32_t[this->nb_samples]();
    tag_counts[sample_id] = value;
    tags_counts[kmer] = tag_counts;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xd030
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xcf80
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xcf50
testb $0x1, %al
jne 0xc9cb
jmp 0xc9e9
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcfb0
movl -0x3c(%rbp), %edx
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0xca58
movq -0x38(%rbp), %rax
movl 0x50(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3030
movq -0x58(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
callq 0x3110
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xd060
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::recurrencyFilter(unsigned int)
void CountsTable::recurrencyFilter(uint recurrency_threshold) {
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts = this->tags_counts.begin();
  while(it_counts != this->tags_counts.end()) {
    uint recurrency = 0;
    for (int s = 0; s < this->nb_samples; ++s) {
      if(it_counts->second[s] > 0) {
        recurrency++;
      }
    }
    if(recurrency >= recurrency_threshold) {
      it_counts++;
    } else {
      it_counts = this->tags_counts.erase(it_counts);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xcf20
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
callq 0xcf80
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xcf50
testb $0x1, %al
jne 0xcb43
jmp 0xcbc9
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x50(%rcx), %eax
jae 0xcb8a
leaq -0x18(%rbp), %rdi
callq 0xcfb0
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0xcb7d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcb7f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xcb51
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jb 0xcba3
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xd090
movq %rax, -0x30(%rbp)
jmp 0xcbc4
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0xd0c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xcb20
addq $0x50, %rsp
popq %rbp
retq
nop
// File: jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::printCounts(char)
void CountsTable::printCounts(char sep) {
  char *tag_seq = new char[this->kmer_length];
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts;

  /* Print Headers */
  std::cout << "tag";
  for (int s = 0; s < this->nb_samples; ++s) {
    std::cout << sep << this->sample_names[s];
  }
  std::cout << std::endl;

  /* Print Counts */
  for (it_counts = tags_counts.begin(); it_counts != tags_counts.end(); ++it_counts) {
    intToDNA(it_counts->first,this->kmer_length,tag_seq);
    std::cout << tag_seq;
    for (int s = 0; s < this->nb_samples; ++s) {
      std::cout << "\t" << it_counts->second[s];
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x54(%rax), %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcf00
movq 0xa3b8(%rip), %rdi      # 0x16fc0
leaq 0x25d7(%rip), %rsi      # 0xf1e6
callq 0x31c0
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x50(%rcx), %eax
jae 0xcc63
movq 0xa392(%rip), %rdi      # 0x16fc0
movsbl -0x9(%rbp), %esi
callq 0x3270
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
movslq -0x24(%rbp), %rsi
callq 0xd010
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x31b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcc1b
movq 0xa356(%rip), %rdi      # 0x16fc0
movq 0xa33f(%rip), %rsi      # 0x16fb0
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0xcf20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
callq 0xcf80
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xcf50
testb $0x1, %al
jne 0xccae
jmp 0xcd50
leaq -0x20(%rbp), %rdi
callq 0xcfb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rdi
movl 0x54(%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x5310
movq -0x18(%rbp), %rsi
movq 0xa2e8(%rip), %rdi      # 0x16fc0
callq 0x31c0
movl $0x0, -0x3c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jae 0xcd2f
movq 0xa2c9(%rip), %rdi      # 0x16fc0
leaq 0x24f7(%rip), %rsi      # 0xf1f5
callq 0x31c0
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcfb0
movq -0x58(%rbp), %rdi
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x32f0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xcce4
movq 0xa28a(%rip), %rdi      # 0x16fc0
movq 0xa273(%rip), %rsi      # 0x16fb0
callq 0x3210
leaq -0x20(%rbp), %rdi
callq 0xcfe0
jmp 0xcc8b
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kuszmaul[P]6886/timers.cc
// Function: loop()
double loop(void) {
    for (size_t t = 0; t < N; t++) {
        for (size_t j = 0; j < N; j++) {
            x[j] += sin(x[j]);
        }
    }
    double sum = 0;
    for (size_t j = 0; j < N; j++) {
        sum += x[j];
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x100, -0x8(%rbp)      # imm = 0x100
jae 0x130b
movq $0x0, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jae 0x12fb
movq -0x10(%rbp), %rcx
leaq 0x2db9(%rip), %rax      # 0x4080
movsd (%rax,%rcx,8), %xmm0
callq 0x1040
movq -0x10(%rbp), %rcx
leaq 0x2da4(%rip), %rax      # 0x4080
addsd (%rax,%rcx,8), %xmm0
leaq 0x2d98(%rip), %rax      # 0x4080
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12b2
jmp 0x12fd
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x12a0
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x100, -0x20(%rbp)     # imm = 0x100
jae 0x134d
movq -0x20(%rbp), %rcx
leaq 0x2d50(%rip), %rax      # 0x4080
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x131b
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kuszmaul[P]6886/timers.cc
// Function: timeit_gettimeofday()
void timeit_gettimeofday(void) {
    struct timeval start, end;
    printf("gettimeofday:\n");
    statistics stats;
    for (int trial = 0; trial < n_trials; trial++) {
        init();
        gettimeofday(&start, NULL);
        loop();
        gettimeofday(&end,   NULL);
        double tim = tdiff_timeval(&start, &end);
        stats.measurement(tim);
        printf(" %12.9fs\n", tim);
    }
    stats.print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0xcd1(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1030
leaq -0x48(%rbp), %rdi
callq 0x1580
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl 0x2cd1(%rip), %eax      # 0x4060
jge 0x13f3
callq 0x1240
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
callq 0x1290
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11a0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
leaq -0x48(%rbp), %rdi
callq 0x15c0
movsd -0x58(%rbp), %xmm0
leaq 0xc6e(%rip), %rdi       # 0x204f
movb $0x1, %al
callq 0x1030
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1386
leaq -0x48(%rbp), %rdi
callq 0x1670
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kuszmaul[P]6886/timers.cc
// Function: timeit_clock_gettime(int, char const*)
void timeit_clock_gettime(clockid_t clk_id, const char *string) {
    struct timespec start, end;
    printf("%s\n", string);
    statistics stats;
    for (int trial = 0; trial < n_trials; trial++) {
        init();
        clock_gettime(clk_id, &start);
        loop();
        clock_gettime(clk_id, &end);
        double tim = tdiff_timespec(&start, &end);
        stats.measurement(tim);
        printf(" %12.9fs\n", tim);
    }
    stats.print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xc2f(%rip), %rdi       # 0x2059
movb $0x0, %al
callq 0x1030
leaq -0x58(%rbp), %rdi
callq 0x1580
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x2c16(%rip), %eax      # 0x4060
jge 0x14ac
callq 0x1240
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
callq 0x1080
callq 0x1290
movl -0x4(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0x1080
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11f0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
leaq -0x58(%rbp), %rdi
callq 0x15c0
movsd -0x68(%rbp), %xmm0
leaq 0xbb5(%rip), %rdi       # 0x204f
movb $0x1, %al
callq 0x1030
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1441
leaq -0x58(%rbp), %rdi
callq 0x1670
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kuszmaul[P]6886/timers.cc
// Function: main
int main(int argc __attribute__((unused)), const char *argv[] __attribute__((unused))) {

    timeit_gettimeofday();
    CGT(REALTIME);
    CGT(MONOTONIC);
    CGT(REALTIME_COARSE);
    CGT(MONOTONIC);
    CGT(MONOTONIC_COARSE);
    CGT(MONOTONIC_RAW);
    CGT(BOOTTIME);
    CGT(PROCESS_CPUTIME_ID);
    CGT(THREAD_CPUTIME_ID);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1360
xorl %edi, %edi
leaq 0xb79(%rip), %rsi       # 0x205d
callq 0x1410
movl $0x1, %edi
leaq 0xb71(%rip), %rsi       # 0x2066
callq 0x1410
movl $0x5, %edi
leaq 0xb6a(%rip), %rsi       # 0x2070
callq 0x1410
movl $0x1, %edi
leaq 0xb4f(%rip), %rsi       # 0x2066
callq 0x1410
movl $0x6, %edi
leaq 0xb58(%rip), %rsi       # 0x2080
callq 0x1410
movl $0x4, %edi
leaq 0xb58(%rip), %rsi       # 0x2091
callq 0x1410
movl $0x7, %edi
leaq 0xb55(%rip), %rsi       # 0x209f
callq 0x1410
movl $0x2, %edi
leaq 0xb4d(%rip), %rsi       # 0x20a8
callq 0x1410
movl $0x3, %edi
leaq 0xb4f(%rip), %rsi       # 0x20bb
callq 0x1410
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kuszmaul[P]6886/timers.cc
// Function: statistics::measurement(double)
void measurement(double f) {
        if (n == 0) {
            min = max = f;
        } else {
            min = std::min(min, f);
            max = std::max(max, f);
        }
        sum += f;
        sum_squares += f*f;
        n++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x15f4
movq -0x18(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd %xmm0, (%rax)
jmp 0x162a
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x16f0
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rdi)
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x1730
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movsd -0x10(%rbp), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: printv(std::vector<int, std::allocator<int>>)
void printv(vector<int> v)
{
    cout << "v(" << v.size() << "): ";
    for (unsigned i = 0; i < v.size(); i++)
        cout << v[i] << " ";
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq 0xcc91(%rip), %rdi      # 0xdfd8
leaq 0x7cb6(%rip), %rsi      # 0x9004
callq 0x10f0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x44b0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1050
movq %rax, %rdi
leaq 0x7c91(%rip), %rsi      # 0x9007
callq 0x10f0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x44b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x13d4
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x44d0
movl (%rax), %esi
movq 0xcc23(%rip), %rdi      # 0xdfd8
callq 0x11b0
movq %rax, %rdi
leaq 0x7ec8(%rip), %rsi      # 0x928c
callq 0x10f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1382
movq 0xcbfd(%rip), %rdi      # 0xdfd8
movq 0xcbe6(%rip), %rsi      # 0xdfc8
callq 0x1130
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: printTable(std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>, std::vector<int, std::allocator<int>>, int)
void printTable(vector<int> choices, vector<vector<pair<int, int>>> selections, vector<int> cancels, int f)
{
    int N = 3 * f + 1;
    for (unsigned i = 0; i < N; i++)
    {
        cout << "R_" << i << " | " << choices[i] << "(" << choices[i] << ") |\t";
        for (unsigned j = 0; j < selections[i].size(); j++)
            cout << selections[i][j].second << "(" << selections[i][j].first << ")\t";
        cout << "| Cancel " << cancels[i] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
imull $0x3, -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x2256
movq 0xbf01(%rip), %rdi      # 0xdfd8
leaq 0x6f7f(%rip), %rsi      # 0x905d
callq 0x10f0
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x1160
movq %rax, %rdi
leaq 0x6f61(%rip), %rsi      # 0x9059
callq 0x10f0
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x44d0
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x11b0
movq %rax, %rdi
leaq 0x6ee1(%rip), %rsi      # 0x9005
callq 0x10f0
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x44d0
movq -0x48(%rbp), %rdi
movl (%rax), %esi
callq 0x11b0
movq %rax, %rdi
leaq 0x6f10(%rip), %rsi      # 0x9060
callq 0x10f0
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %eax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4d30
movq %rax, %rdi
callq 0x4da0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2209
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4d30
movq %rax, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x4d50
movl 0x4(%rax), %esi
movq 0xbe2a(%rip), %rdi      # 0xdfd8
callq 0x11b0
movq %rax, %rdi
leaq 0x6e48(%rip), %rsi      # 0x9005
callq 0x10f0
movq -0x38(%rbp), %rdi
movq %rax, -0x60(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4d30
movq %rax, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x4d50
movq -0x60(%rbp), %rdi
movl (%rax), %esi
callq 0x11b0
movq %rax, %rdi
leaq 0x6e6f(%rip), %rsi      # 0x9065
callq 0x10f0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x215c
movq 0xbdc8(%rip), %rdi      # 0xdfd8
leaq 0x6e51(%rip), %rsi      # 0x9068
callq 0x10f0
movq -0x30(%rbp), %rdi
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x44d0
movq -0x68(%rbp), %rdi
movl (%rax), %esi
callq 0x11b0
movq %rax, %rdi
movq 0xbd85(%rip), %rsi      # 0xdfc8
callq 0x1130
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20c4
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: Naomi1745698[P]BigPrac/test.cpp
// Function: test::meteorTesting()
void test::meteorTesting(){
	PASS = 0;
	std::cout << "the meteor size is: " << meteor1->getHealth() << std::endl;
	if(meteor1->getHealth() == 25){
		PASS++;
	}else{
		PASS--;
		std::cout << "ERROR meteorsize" << std::endl;
	};
	std::cout << "set meteor size to original + 20" << std::endl;
	meteor1->setHealth(20); //adds 20 to size
	std::cout << "the meteor size is: " << meteor1->getHealth() << std::endl;
	if(meteor1->getHealth() == 45){
		PASS++;
	}else{
		PASS--;
		std::cout << "ERROR set meteorsize" << std::endl;
	}
	if(PASS == 2){
		std::cout << "<---------------------PASS---------------->" << std::endl;		
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, 0x74(%rax)
movq 0x4816(%rip), %rdi      # 0xdfd8
leaq 0x12ef(%rip), %rsi      # 0xaab8
callq 0x31c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x3320
movq %rax, %rdi
movq 0x47d1(%rip), %rsi      # 0xdfc8
callq 0x31f0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x19, %eax
jne 0x981d
movq -0x10(%rbp), %rax
movl 0x74(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x74(%rax)
jmp 0x984c
movq -0x10(%rbp), %rax
movl 0x74(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x74(%rax)
movq 0x47a7(%rip), %rdi      # 0xdfd8
leaq 0x1295(%rip), %rsi      # 0xaacd
callq 0x31c0
movq %rax, %rdi
movq 0x4781(%rip), %rsi      # 0xdfc8
callq 0x31f0
movq 0x4785(%rip), %rdi      # 0xdfd8
leaq 0x1284(%rip), %rsi      # 0xaade
callq 0x31c0
movq %rax, %rdi
movq 0x475f(%rip), %rsi      # 0xdfc8
callq 0x31f0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movl $0x14, %esi
callq *0x10(%rax)
movq 0x4750(%rip), %rdi      # 0xdfd8
leaq 0x1229(%rip), %rsi      # 0xaab8
callq 0x31c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x3320
movq %rax, %rdi
movq 0x470b(%rip), %rsi      # 0xdfc8
callq 0x31f0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2d, %eax
jne 0x98e3
movq -0x10(%rbp), %rax
movl 0x74(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x74(%rax)
jmp 0x9912
movq -0x10(%rbp), %rax
movl 0x74(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x74(%rax)
movq 0x46e1(%rip), %rdi      # 0xdfd8
leaq 0x1201(%rip), %rsi      # 0xaaff
callq 0x31c0
movq %rax, %rdi
movq 0x46bb(%rip), %rsi      # 0xdfc8
callq 0x31f0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x74(%rax)
jne 0x993e
movq 0x46b5(%rip), %rdi      # 0xdfd8
leaq 0x10ff(%rip), %rsi      # 0xaa29
callq 0x31c0
movq %rax, %rdi
movq 0x468f(%rip), %rsi      # 0xdfc8
callq 0x31f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Naomi1745698[P]BigPrac/test.cpp
// Function: test::~test()
test::~test(){
	delete playerShip;
	delete playerShip1;	
	delete planet1;
	delete meteor1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x9989
movq -0x10(%rbp), %rdi
callq 0x4682
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0x31e0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x99b2
movq -0x20(%rbp), %rdi
callq 0x4682
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0x31e0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x99db
movq -0x28(%rbp), %rdi
callq 0x4172
movq -0x28(%rbp), %rdi
movl $0x38, %esi
callq 0x31e0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9a04
movq -0x30(%rbp), %rdi
callq 0x4172
movq -0x30(%rbp), %rdi
movl $0x38, %esi
callq 0x31e0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x30f0
addq $0x30, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/equiv-istream-iter.cc
// Function: main
int main() {
	// use istream_iterator to initialize a vector
	istream_iterator<int> in_iter(cin), eof;  
	vector<int> vec(in_iter, eof);  

	for (auto it : vec)
		cout << it << " ";
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movq 0x3d37(%rip), %rsi      # 0x4fe0
leaq -0x18(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1430
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1460
movq -0xc0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1480
movq -0xb8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1480
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x14c0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x14e0
jmp 0x1327
leaq -0x61(%rbp), %rdi
callq 0x1580
leaq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x15a0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x15d0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1600
testb $0x1, %al
jne 0x1374
jmp 0x13f6
leaq -0x88(%rbp), %rdi
callq 0x1640
movl (%rax), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %esi
movq 0x3c3b(%rip), %rdi      # 0x4fd0
callq 0x1130
movq %rax, -0xc8(%rbp)
jmp 0x13a3
movq -0xc8(%rbp), %rdi
leaq 0x1c53(%rip), %rsi      # 0x3004
callq 0x10b0
jmp 0x13b8
jmp 0x13ba
leaq -0x88(%rbp), %rdi
callq 0x1660
jmp 0x1358
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x1580
jmp 0x1427
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1680
jmp 0x1427
movq 0x3bd3(%rip), %rdi      # 0x4fd0
movq 0x3bbc(%rip), %rsi      # 0x4fc0
callq 0x10e0
jmp 0x140b
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1680
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1140
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: unsigned long moodycamel::details::ceil_to_pow_2<unsigned long>(unsigned long)
static inline T ceil_to_pow_2(T x)
	{
		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");

		// Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
		--x;
		x |= x >> 1;
		x |= x >> 2;
		x |= x >> 4;
		for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
			x |= x >> (i << 3);
		}
		++x;
		return x;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
cmpq $0x8, -0x10(%rbp)
jae 0x39d6
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
shrq %cl, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
jmp 0x39ab
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/thread_pool.hpp
// Function: std::future<std::result_of<void (& ())()>::type> thread::pool::parameterized_pool_t<1ul, 0l>::schedule<void (&)()>(void (&)())
std::future<typename std::result_of<F(Args...)>::type> schedule(F&& f, Args&&... args) {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(
          std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        std::future<return_type> future = task->get_future();
        if (!tasks_.enqueue([task] () { (*task)(); })) {
          throw std::length_error("Couldn't enqueue the given callable object");
        }
        return (future);
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc4c0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xc450
movq -0x90(%rbp), %rdi
movb $0x0, -0x39(%rbp)
callq 0xc4f0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xc510
jmp 0x3c65
movq -0x98(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb0(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xc5f0
movq -0xa8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xc620
jmp 0x3c9d
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xc580
movb %al, -0xb1(%rbp)
jmp 0x3cb5
movb -0xb1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xb2(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6fc0
leaq -0x80(%rbp), %rdi
callq 0xc6c0
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0x3ce4
jmp 0x3d8f
movl $0x10, %edi
callq 0x3100
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
leaq 0x14e63(%rip), %rsi     # 0x18b65
callq 0x32a0
jmp 0x3d09
movq -0xc0(%rbp), %rdi
movq 0x202b9(%rip), %rsi     # 0x23fd0
movq 0x2027a(%rip), %rdx     # 0x23f98
callq 0x3380
jmp 0x3ddc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3dca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3d5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6fc0
leaq -0x80(%rbp), %rdi
callq 0xc6c0
jmp 0x3dbe
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x31a0
jmp 0x3dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3dbe
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x3da5
movq -0x88(%rbp), %rdi
callq 0x3de0
leaq -0x28(%rbp), %rdi
callq 0xc6e0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3de0
leaq -0x28(%rbp), %rdi
callq 0xc6e0
movq -0x48(%rbp), %rdi
callq 0x3390
nopl (%rax)
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/thread_pool.hpp
// Function: thread::pool::parameterized_pool_t<1ul, 0l>::worker()
void worker() {
        auto token = create_token_of<thread::pool::consumer_token_t>();
        while (!done_) {
          consumer_t runnable[BULK_MAX_ITEMS] = {};
          auto available = tasks_.wait_dequeue_bulk_timed(token, runnable, BULK_MAX_ITEMS, std::chrono::milliseconds(DEQUEUE_TIMEOUT));
          for (size_t i = 0; i < available; ++i) {
            runnable[i]();
          }
        }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6e00
movq -0x88(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
callq 0x6e30
xorb $-0x1, %al
testb $0x1, %al
jne 0x4cc1
jmp 0x4e4d
leaq -0x50(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x98(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6eb0
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x90(%rbp)
jne 0x4cdb
movq -0x88(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq $0x0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6f60
jmp 0x4d40
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %ecx
leaq -0x60(%rbp), %r8
callq 0x6ef0
movq %rax, -0xb8(%rbp)
jmp 0x4d69
movq -0xb8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x4dce
movq -0x80(%rbp), %rax
shlq $0x5, %rax
leaq -0x50(%rbp,%rax), %rdi
callq 0x6f80
jmp 0x4d9a
jmp 0x4d9c
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x4d7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xc8(%rbp)
addq $0x20, %rax
movq %rax, -0xc0(%rbp)
jmp 0x4e1a
leaq -0x50(%rbp), %rax
movq %rax, -0xd8(%rbp)
addq $0x20, %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6fc0
movq -0xd8(%rbp), %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xd0(%rbp)
jne 0x4de4
jmp 0x4ca3
movq -0xc0(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xe8(%rbp)
callq 0x6fc0
movq -0xc8(%rbp), %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xc0(%rbp)
jne 0x4e1a
jmp 0x4e56
addq $0xf0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3390
nop
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ConcurrentQueue(unsigned long)
explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
		: producerListTail(nullptr),
		producerCount(0),
		initialBlockPoolIndex(0),
		nextExplicitConsumerId(0),
		globalExplicitConsumerOffset(0)
	{
		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
		populate_initial_implicit_producer_hash();
		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
		
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
		// Track all the producers using a fully-resolved typed list for
		// each kind; this makes it possible to debug them starting from
		// the root queue object (otherwise wacky casts are needed that
		// don't compile in the debugger's expression evaluator).
		explicitProducers.store(nullptr, std::memory_order_relaxed);
		implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
movl %eax, %esi
movq %rsi, -0x50(%rbp)
callq 0x54d0
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
addq $0x8, %rdi
callq 0x5500
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x5530
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x5560
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0x5580
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq %rdi, %rax
addq $0x258, %rax            # imm = 0x258
movq %rax, -0x38(%rbp)
addq $0x25c, %rdi            # imm = 0x25C
callq 0x5500
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
addq $0x260, %rdi            # imm = 0x260
callq 0x5500
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x58d0
movl %eax, -0x24(%rbp)
jmp 0x514f
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0x3, %eax
je 0x5175
jmp 0x5162
movl -0x54(%rbp), %eax
subl $0x5, %eax
je 0x517e
jmp 0x516c
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0x5190
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0x5190
movq -0x30(%rbp), %rcx
xorl %eax, %eax
xchgb %al, (%rcx)
jmp 0x5190
movq %rax, %rdi
callq 0x4410
movq -0x48(%rbp), %rdi
callq 0x55d0
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
shrq $0x5, %rsi
movq -0x20(%rbp), %rdx
andq $0x1f, %rdx
movl $0x1, %eax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
cltq
addq %rax, %rsi
callq 0x5760
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::~ConcurrentQueue()
~ConcurrentQueue()
	{
		// Destroy producers
		auto ptr = producerListTail.load(std::memory_order_relaxed);
		while (ptr != nullptr) {
			auto next = ptr->next_prod();
			if (ptr->token != nullptr) {
				ptr->token->producer = nullptr;
			}
			destroy(ptr);
			ptr = next;
		}
		
		// Destroy implicit producer hash tables
		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
			while (hash != nullptr) {
				auto prev = hash->prev;
				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
					for (size_t i = 0; i != hash->capacity; ++i) {
						hash->entries[i].~ImplicitProducerKVP();
					}
					hash->~ImplicitProducerHash();
					(Traits::free)(hash);
				}
				hash = prev;
			}
		}
		
		// Destroy global free list
		auto block = freeList.head_unsafe();
		while (block != nullptr) {
			auto next = block->freeListNext.load(std::memory_order_relaxed);
			if (block->dynamicallyAllocated) {
				destroy(block);
			}
			block = next;
		}
		
		// Destroy initial free list
		destroy_array(initialBlockPool, initialBlockPoolSize);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
callq 0x6080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x53ec
movq -0x10(%rbp), %rdi
callq 0x6100
movq %rax, -0x50(%rbp)
jmp 0x53b5
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x53d7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6140
jmp 0x53e2
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x539f
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x6170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x544f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5445
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
je 0x543c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5421
movq -0x20(%rbp), %rdi
callq 0x5cc0
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x53ff
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x61f0
movq %rax, -0x58(%rbp)
jmp 0x5462
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x54ab
movq -0x38(%rbp), %rdi
addq $0x438, %rdi            # imm = 0x438
xorl %esi, %esi
callq 0x6210
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x441(%rax)
je 0x54a1
movq -0x38(%rbp), %rdi
callq 0x6290
jmp 0x549f
jmp 0x54a1
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x546a
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x62c0
jmp 0x54be
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4410
nopl (%rax)
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_implicit_producer_hash()
inline void populate_initial_implicit_producer_hash()
	{
		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
			return;
		}
		else {
			implicitProducerHashCount.store(0, std::memory_order_relaxed);
			auto hash = &initialImplicitProducerHash;
			hash->capacity = INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
			hash->entries = &initialImplicitProducerHashEntries[0];
			for (size_t i = 0; i != INITIAL_IMPLICIT_PRODUCER_HASH_SIZE; ++i) {
				initialImplicitProducerHashEntries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
			}
			hash->prev = nullptr;
			implicitProducerHash.store(hash, std::memory_order_relaxed);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x38, %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x14(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x58d0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
je 0x5642
jmp 0x562b
movl -0x5c(%rbp), %eax
subl $0x5, %eax
je 0x564f
jmp 0x5635
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x565a
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x565a
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
xchgq %rax, (%rcx)
movq -0x70(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq $0x20, (%rax)
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x58f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x58(%rbp)
cmpq $0x20, -0x58(%rbp)
je 0x5732
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
movq -0x58(%rbp), %rsi
callq 0x58f0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x34(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x58d0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x40(%rbp)
subl $0x3, %eax
je 0x5707
jmp 0x56f0
movl -0x74(%rbp), %eax
subl $0x5, %eax
je 0x5714
jmp 0x56fa
movq -0x80(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x571f
movq -0x80(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x571f
movq -0x80(%rbp), %rcx
movq -0x40(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0x5721
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x5694
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x30, %rdi
movq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x5920
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(unsigned long)
void populate_initial_block_list(size_t blockCount)
	{
		initialBlockPoolSize = blockCount;
		if (initialBlockPoolSize == 0) {
			initialBlockPool = nullptr;
			return;
		}
		
		initialBlockPool = create_array<Block>(blockCount);
		if (initialBlockPool == nullptr) {
			initialBlockPoolSize = 0;
		}
		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
			initialBlockPool[i].dynamicallyAllocated = false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x5795
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x57fa
movq -0x10(%rbp), %rdi
callq 0x59d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x57bc
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0x57fa
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x448, -0x18(%rbp), %rcx # imm = 0x448
addq %rcx, %rax
movb $0x0, 0x441(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x57c4
addq $0x20, %rsp
popq %rbp
retq