LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::write_inout_info(scdc_transport_connection_t*, _scdc_dataset_inout_t*)
static bool write_inout_info(scdc_transport_connection_t *transport_connection_, scdc_dataset_inout_t *inout)
    {
      scdc_dataset_inout_t inout_null;
      if (!inout)
      {
        scdc_dataset_inout_unset(&inout_null);
        inout = &inout_null;
      }

      scdcint_t inout_buf_current = 0;
#if SCDC_DATASET_INOUT_BUF_MULTIPLE
      if (SCDC_DATASET_INOUT_MBUF_ISSET(inout))
      {
        scdcint_t i;
        for (i = 0; i < SCDC_DATASET_INOUT_MBUF_GET_C(inout); ++i) inout_buf_current += SCDC_DATASET_INOUT_MBUF_M_CURRENT(inout, i);

      } else
#endif
      {
        inout_buf_current = SCDC_DATASET_INOUT_BUF_CURRENT(inout);
      }

      char info[256];
      scdcint_t n = sprintf(info, "%s|%" scdcint_fmt "|%c|%" scdcint_fmt "|%d", inout->format, inout->total_size, inout->total_size_given, inout_buf_current, (inout->next)?1:0);

      if (!write_delim(transport_connection_, info, n, default_delim))
      {
        SCDC_FAIL("write_inout_info: write failed");
        return false;
      }

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x6747e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2adfe
cmpq $0x0, 0x18(%r14)
movq 0x20(%r14), %r9
jns 0x674ba
testq %r9, %r9
js 0x67493
xorl %r9d, %r9d
jmp 0x674ba
negq %r9
movq 0x10(%r14), %rax
cmpq $0x2, %r9
movl $0x1, %ecx
cmovgeq %r9, %rcx
addq $0x10, %rax
xorl %r9d, %r9d
addq (%rax), %r9
addq $0x18, %rax
decq %rcx
jne 0x674ae
movq 0x28(%r14), %rcx
movsbl 0x30(%r14), %r8d
xorl %eax, %eax
cmpq $0x0, 0x38(%r14)
setne %al
movl %eax, (%rsp)
leaq 0x700c(%rip), %rsi      # 0x6e4e3
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb0d0
movslq %eax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x20, %ecx
callq 0x6638a
movl %eax, %ebx
testb %al, %al
jne 0x67596
leaq 0x25063(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x67596
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x2c7a(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x692d(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x6fa0(%rip), %rsi      # 0x6e4f6
movl $0x1e, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/data.cc
// Function: scdc_data::compact()
void scdc_data::compact()
{
  if (read_pos <= 0) return;

  SCDC_TRACE("compact: " << write_pos - read_pos << " bytes at offset " << read_pos);

  if (read_pos < write_pos) memmove(buf, buf + read_pos, write_pos - read_pos);

  write_pos -= read_pos;
  read_pos = 0;
}

// Assembly:
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
jle 0x67831
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rax, %rdx
subq %rsi, %rdx
jle 0x67821
movq 0x8(%rbx), %rdi
addq %rdi, %rsi
callq 0xb930
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rsi
subq %rsi, %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/countTags.cpp
// Function: join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char const*)
std::string join( const std::vector<std::string>& elements, const char* const separator)
{
  switch (elements.size())
  {
    case 0:
      return "";
    case 1:
      return elements[0];
    default:
      std::ostringstream os;
      std::copy(elements.begin(), elements.end()-1, std::ostream_iterator<std::string>(os, separator));
      os << *elements.rbegin();
      return os.str();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq $0x1, %rcx
je 0x2586
testq %rcx, %rcx
jne 0x25a4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4bcc(%rip), %rdx      # 0x7142
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4080
jmp 0x263c
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3fea
jmp 0x263c
movq %rdx, %r12
movq %rsi, %r14
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x2240
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %r13, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq %rax, %r13
subq %r15, %r13
addq $-0x20, %r13
sarq $0x5, %r13
testq %r13, %r13
jle 0x25ff
incq %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4116
addq $0x20, %r15
decq %r13
cmpq $0x1, %r13
ja 0x25e3
movq 0x8(%r14), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
leaq 0x18(%rsp), %rdi
callq 0x21c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x22b0
movq 0x799b(%rip), %rsi      # 0x9fc0
leaq 0x18(%rsp), %rdi
callq 0x20e0
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2654
jmp 0x2654
movq %rax, %rbx
movq 0x7962(%rip), %rsi      # 0x9fc0
leaq 0x18(%rsp), %rdi
callq 0x20e0
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/countTags.cpp
// Function: Arg::Numeric(option::Option const&, bool)
static option::ArgStatus Numeric(const option::Option& option, bool msg)
  {
    char* endptr = 0;
    if (option.arg != 0 && strtol(option.arg, &endptr, 10)){};
    if (endptr != option.arg && *endptr == 0)
      return option::ARG_OK;

    if (msg) printError("Option '", option, "' requires a numeric argument\n");
    return option::ARG_ILLEGAL;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x3802
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x2250
movq (%r14), %rcx
cmpq 0x20(%rbx), %rcx
je 0x3802
xorl %eax, %eax
cmpb $0x0, (%rcx)
setne %cl
testb %bpl, %cl
jne 0x3815
movb %cl, %al
leal 0x1(,%rax,2), %eax
jmp 0x380c
movl $0x3, %eax
testb %bpl, %bpl
jne 0x3815
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3a72(%rip), %rdi      # 0x728e
leaq 0x3a74(%rip), %rdx      # 0x7297
movq %rbx, %rsi
callq 0x2360
movl $0x3, %eax
jmp 0x380c
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/optionparser.h
// Function: option::Option::init(option::Descriptor const*, char const*, char const*)
void init(const Descriptor* desc_, const char* name_, const char* arg_)
  {
    desc = desc_;
    name = name_;
    arg = arg_;
    prev_ = tag(this);
    next_ = tag(this);
    namelen = 0;
    if (name == 0)
      return;
    namelen = 1;
    if (name[0] != '-')
      return;
    while (name[namelen] != 0 && name[namelen] != '=')
      ++namelen;
  }

// Assembly:
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rdi, %rax
orq $0x1, %rax
movq %rax, 0x8(%rdi)
movq %rax, (%rdi)
movl $0x0, 0x28(%rdi)
testq %rdx, %rdx
je 0x3d88
movl $0x1, 0x28(%rdi)
cmpb $0x2d, (%rdx)
jne 0x3d88
movl $0x1, %eax
movzbl (%rdx,%rax), %ecx
testl %ecx, %ecx
je 0x3d88
cmpl $0x3d, %ecx
je 0x3d88
incq %rax
movl %eax, 0x28(%rdi)
jmp 0x3d73
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::StoreOptionAction::perform(option::Option&)
bool perform(Option& option)
  {
    if (bufmax < 0 || parser.op_count < bufmax)
    {
      if (parser.op_count == 0x7fffffff)
        return false; // overflow protection: don't accept number of options that doesn't fit signed int

      buffer[parser.op_count] = option;
      int idx = buffer[parser.op_count].desc->index;
      if (options[idx])
        options[idx].append(buffer[parser.op_count]);
      else
        options[idx] = buffer[parser.op_count];
      ++parser.op_count;
    }
    return true; // NOTE: an option that is discarded because of a full buffer is not fatal
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %edx
movq 0x8(%rdi), %rax
movslq (%rax), %rcx
testl %edx, %edx
js 0x3da7
movb $0x1, %al
cmpl %edx, %ecx
jl 0x3db6
jmp 0x3e63
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0x3db6
xorl %eax, %eax
jmp 0x3e63
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq 0x18(%rbx), %rdi
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq 0x20(%rsi), %rcx
movq %rax, %rsi
callq 0x3d3c
movq 0x18(%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
movslq (%rax), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
leaq (%rsi,%rdi), %r8
movq 0x10(%rsi,%rdi), %rsi
movslq (%rsi), %rdi
leaq (%rdi,%rdi,2), %r9
shlq $0x4, %r9
leaq (%rdx,%r9), %rdi
testq %rdx, %rdx
je 0x3e4a
cmpq $0x0, 0x10(%rdx,%r9)
je 0x3e4a
movq %rdi, %rdx
movq 0x8(%rdx), %rdx
testb $0x1, %dl
je 0x3e15
movq %rdi, %rsi
movq 0x8(%rdi), %rdi
testb $0x1, %dil
je 0x3e1e
andq $-0x2, %rdx
movq %r8, (%rdx)
movq %rdx, 0x8(%r8)
movq %rsi, %rdx
orq $0x1, %rdx
movq %rdx, (%r8)
orq $0x1, %r8
movq %r8, 0x8(%rsi)
jmp 0x3e5d
movq 0x18(%r8), %rdx
movq 0x20(%r8), %rcx
callq 0x3d3c
movq 0x8(%rbx), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::nextTable()
bool nextTable()
    {
      // If this is NOT the first time nextTable() is called after the constructor,
      // then skip to the next table break (i.e. a Descriptor with help == 0)
      if (rowdesc != 0)
      {
        while (tablestart->help != 0 && tablestart->shortopt != 0)
          ++tablestart;
      }

      // Find the next table after the break (if any)
      while (tablestart->help == 0 && tablestart->shortopt != 0)
        ++tablestart;

      restartTable();
      return rowstart != 0;
    }

// Assembly:
cmpq $0x0, 0x8(%rdi)
movq (%rdi), %rcx
je 0x46d3
cmpq $0x0, 0x20(%rcx)
je 0x46d3
cmpq $0x0, 0x8(%rcx)
je 0x46d3
leaq 0x28(%rcx), %rax
movq %rax, (%rdi)
cmpq $0x0, 0x48(%rcx)
movq %rax, %rcx
jne 0x46b9
jmp 0x46d6
movq %rcx, %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x46f7
movq %rax, %rdx
jmp 0x4703
leaq 0x28(%rax), %rdx
movq %rdx, (%rdi)
movq 0x48(%rax), %rcx
movq %rdx, %rax
testq %rcx, %rcx
jne 0x4703
cmpq $0x0, 0x8(%rax)
jne 0x46e4
movq %rax, %rdx
xorl %ecx, %ecx
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
testq %rcx, %rcx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::next()
bool next()
    {
      if (ptr == 0)
        return false;

      if (col == -1)
      {
        col = 0;
        update_length();
        return true;
      }

      ptr += len;
      while (true)
      {
        switch (*ptr)
        {
          case '\v':
            upmax(max_line_in_block, ++line_in_block);
            ++ptr;
            break;
          case '\t':
            if (!hit_target_line) // if previous column did not have the targetline
            { // then "insert" a 0-length part
              update_length();
              hit_target_line = true;
              return true;
            }

            hit_target_line = false;
            line_in_block = 0;
            ++col;
            ++ptr;
            break;
          case 0:
          case '\n':
            if (!hit_target_line) // if previous column did not have the targetline
            { // then "insert" a 0-length part
              update_length();
              hit_target_line = true;
              return true;
            }

            if (++target_line_in_block > max_line_in_block)
            {
              update_length();
              return false;
            }

            hit_target_line = false;
            line_in_block = 0;
            col = 0;
            ptr = rowstart;
            continue;
          default:
            ++ptr;
            continue;
        } // switch

        if (line_in_block == target_line_in_block)
        {
          update_length();
          hit_target_line = true;
          return true;
        }
      } // while
    }

// Assembly:
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x47f6
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %esi
cmpl $-0x1, %esi
je 0x47f9
movslq 0x24(%rbx), %rax
addq %rax, %rdx
movq %rdx, 0x18(%rbx)
movq 0x10(%rbx), %rax
movb 0x38(%rbx), %r9b
movl 0x34(%rbx), %edi
movl 0x2c(%rbx), %ecx
movl 0x30(%rbx), %r8d
movzbl (%rdx), %r10d
cmpl $0x9, %r10d
jg 0x4787
testl %r10d, %r10d
je 0x478d
cmpl $0x9, %r10d
jne 0x47be
testb $0x1, %r9b
je 0x47e8
movb $0x0, 0x38(%rbx)
movl $0x0, 0x30(%rbx)
incl %esi
movl %esi, 0x20(%rbx)
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0x47d8
cmpl $0xa, %r10d
jne 0x47b8
testb $0x1, %r9b
je 0x47e8
leal 0x1(%rdi), %esi
movl %esi, 0x34(%rbx)
cmpl %ecx, %edi
jge 0x480c
movb $0x0, 0x38(%rbx)
xorl %r8d, %r8d
movl %r8d, 0x30(%rbx)
movl %r8d, 0x20(%rbx)
movq %rax, %rdx
movl %esi, %edi
xorl %r9d, %r9d
xorl %esi, %esi
jmp 0x47c1
cmpl $0xb, %r10d
je 0x47c7
incq %rdx
movq %rdx, 0x18(%rbx)
jmp 0x4754
incl %r8d
movl %r8d, 0x30(%rbx)
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movl %ecx, 0x2c(%rbx)
incq %rdx
movq %rdx, 0x18(%rbx)
cmpl %edi, %r8d
jne 0x4754
movq %rbx, %rdi
callq 0x4a80
movb $0x1, 0x38(%rbx)
jmp 0x4808
xorl %eax, %eax
retq
movl $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x4a80
movb $0x1, %al
jmp 0x4816
movq %rbx, %rdi
callq 0x4a80
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %ebp
subl (%rsi), %ebp
jns 0x4848
movq (%r15), %rax
leaq 0x2a78(%rip), %rsi      # 0x72b4
movq %r15, %rdi
movl $0x1, %edx
callq *(%rax)
movl %ebx, %ebp
testl %ebp, %ebp
jle 0x486d
leaq 0xf(%rsp), %r12
movb $0x20, (%r12)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *(%rax)
decl %ebp
jne 0x4856
movl %ebx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::update_length()
void update_length()
    {
      screenlen = 0;
      for (len = 0; ptr[len] != 0 && ptr[len] != '\v' && ptr[len] != '\t' && ptr[len] != '\n'; ++len)
      {
        ++screenlen;
        unsigned ch = (unsigned char) ptr[len];
        if (ch > 0xC1) // everything <= 0xC1 (yes, even 0xC1 itself) is not a valid UTF-8 start byte
        {
          // int __builtin_clz (unsigned int x)
          // Returns the number of leading 0-bits in x, starting at the most significant bit
          unsigned mask = (unsigned) -1 >> __builtin_clz(ch ^ 0xff);
          ch = ch & mask; // mask out length bits, we don't verify their correctness
          while (((unsigned char) ptr[len + 1] ^ 0x80) <= 0x3F) // while next byte is continuation byte
          {
            ch = (ch << 6) ^ (unsigned char) ptr[len + 1] ^ 0x80; // add continuation to char code
            ++len;
          }
          // ch is the decoded unicode code point
          if (ch >= 0x1100 && isWideChar(ch)) // the test for 0x1100 is here to avoid the function call in the Latin case
            ++screenlen;
        }
      }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x28(%rdi)
xorl %eax, %eax
movl $0x80, %ebp
movl $0xe01, %r14d           # imm = 0xE01
movl %eax, 0x24(%rbx)
movq 0x18(%rbx), %rdx
movslq %eax, %rsi
movzbl (%rdx,%rsi), %eax
cmpl $0xb, %eax
ja 0x4ab4
btl %eax, %r14d
jb 0x4b30
incl 0x28(%rbx)
movzbl (%rdx,%rsi), %edi
cmpl $0xc2, %edi
jb 0x4b26
movzbl 0x1(%rdx,%rsi), %eax
movl %eax, %ecx
xorl $0x80, %ecx
cmpl $0x3f, %ecx
ja 0x4b26
movl %edi, %ecx
xorl $0xff, %ecx
bsrl %ecx, %ecx
notl %ecx
shll %cl, %edi
shrl %cl, %edi
leal 0x1(%rsi), %ecx
addq %rsi, %rdx
addq $0x2, %rdx
movl %edi, %esi
shll $0x6, %esi
xorl %esi, %eax
movl %eax, %edi
xorl %ebp, %edi
movl %ecx, 0x24(%rbx)
movzbl (%rdx), %eax
movl %eax, %r8d
xorl %ebp, %r8d
incl %ecx
incq %rdx
cmpl $0x40, %r8d
jb 0x4af0
cmpl $0x1100, %esi           # imm = 0x1100
jb 0x4b26
callq 0x4b36
testb %al, %al
je 0x4b26
incl 0x28(%rbx)
movl 0x24(%rbx), %eax
incl %eax
jmp 0x4a9b
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xd0(%rdi)
jne 0x4c34
movq (%r14), %rax
leaq 0x26a3(%rip), %rsi      # 0x72b4
movq %r14, %rdi
movl $0x1, %edx
callq *(%rax)
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movl 0xc0(%rbx), %edx
movq %r14, %rdi
callq 0x4818
movl 0xcc(%rbx), %eax
incl %eax
andl $0xf, %eax
cmpl 0xc8(%rbx), %eax
je 0x4c5f
movl %eax, 0xcc(%rbx)
movl %eax, %eax
movq 0x40(%rbx,%rax,8), %rsi
movl (%rbx,%rax,4), %edx
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movb $0x1, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movl %edx, %ebx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x605e
testq %rax, %rax
je 0x57fd
movq 0x10(%rax), %rax
movl %ebx, %ecx
movl (%rax,%rcx,4), %eax
jmp 0x57ff
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x605e
testq %rax, %rax
je 0x5935
movq 0x10(%rax), %rax
movl %ebp, %ecx
movl %ebx, (%rax,%rcx,4)
jmp 0x596b
movl 0x50(%r14), %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
movl %ebp, %eax
movl %ebx, (%r12,%rax,4)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x60ba
movq %r12, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x54(%rdi), %edi
callq 0x2030
movq %rax, %r14
movq 0x4492(%rip), %r15      # 0x9fc8
leaq 0x15f5(%rip), %rsi      # 0x7132
movl $0x3, %edx
movq %r15, %rdi
callq 0x21c0
cmpl $0x0, 0x50(%rbx)
je 0x5b98
movl $0x8, %r12d
xorl %r13d, %r13d
movb %bpl, 0x7(%rsp)
movl $0x1, %edx
movq 0x445e(%rip), %rdi      # 0x9fc8
leaq 0x7(%rsp), %rsi
callq 0x21c0
movq 0x38(%rbx), %rcx
movq -0x8(%rcx,%r12), %rsi
movq (%rcx,%r12), %rdx
movq %rax, %rdi
callq 0x21c0
incq %r13
movl 0x50(%rbx), %eax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x5b59
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq 0x10(%rbx), %r13
testq %r13, %r13
je 0x5c7b
leaq 0x156e(%rip), %r12      # 0x7141
movl 0x54(%rbx), %eax
testq %rax, %rax
je 0x5bff
movq 0x8(%r13), %rdx
leal (,%rdx,8), %ecx
movl $0x54474341, %esi       # imm = 0x54474341
shrl %cl, %esi
decq %rax
movl %eax, %ecx
movb %sil, (%r14,%rcx)
shrq $0x2, %rdx
testq %rax, %rax
jne 0x5bdf
movq %r14, %rdi
callq 0x20c0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21c0
cmpl $0x0, 0x50(%rbx)
je 0x5c47
xorl %ebp, %ebp
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
movq 0x10(%r13), %rax
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
callq 0x2100
incq %rbp
movl 0x50(%rbx), %eax
cmpq %rax, %rbp
jb 0x5c1d
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movq (%r13), %r13
testq %r13, %r13
jne 0x5bd3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaudoux[P]countTags/src/dna.h
// Function: DNAtoInt(char const*, unsigned int, bool)
inline uint64_t DNAtoInt(const char *dna, uint32_t dna_length, bool stranded = false){
  uint64_t dna_int = 0;
  for (uint32_t i = 0; i< dna_length ; i++){
    dna_int <<= 2;
    dna_int |= convNuc(dna[i]);
  }
  // If the conversion is not "strand-specific" we calculate the reverse DNA it
  // and return the one that has the smallest value
  if(!stranded) {
    uint64_t rev_comp = intRevcomp(dna_int,dna_length);
    if(rev_comp < dna_int) {
      return rev_comp;
    }
  }
  return dna_int;
}

// Assembly:
testl %esi, %esi
je 0x5d56
pushq %rbx
movl %esi, %ecx
xorl %r8d, %r8d
movabsq $0x100000001, %r9       # imm = 0x100000001
movabsq $0x1000000010, %r10     # imm = 0x1000000010
movabsq $0x2000000020000, %r11  # imm = 0x2000000020000
xorl %eax, %eax
movzbl (%rdi,%r8), %ebx
addl $-0x43, %ebx
cmpl $0x31, %ebx
ja 0x5d00
btq %rbx, %r9
jb 0x5cea
btq %rbx, %r10
jb 0x5ce3
btq %rbx, %r11
movl $0x0, %ebx
jae 0x5cef
movl $0x3, %ebx
jmp 0x5cef
movl $0x2, %ebx
jmp 0x5cef
movl $0x1, %ebx
shlq $0x2, %rax
orq %rbx, %rax
incq %r8
cmpq %r8, %rcx
jne 0x5cb8
jmp 0x5d04
xorl %ebx, %ebx
jmp 0x5cef
testb %dl, %dl
popq %rbx
jne 0x5d62
leal (%rsi,%rsi), %ecx
movq $-0x1, %rdi
movq $-0x1, %rdx
shlq %cl, %rdx
cmpl $0x20, %esi
notq %rdx
cmoveq %rdi, %rdx
testl %esi, %esi
je 0x5d59
xorq %rax, %rdx
movl $0x3, %r8d
xorl %edi, %edi
xorl %ecx, %ecx
shlq $0x2, %rdi
movq %r8, %r9
andq %rdx, %r9
shrq %cl, %r9
orq %r9, %rdi
shlq $0x2, %r8
addq $0x2, %rcx
decl %esi
jne 0x5d38
jmp 0x5d5b
xorl %eax, %eax
retq
xorl %edi, %edi
cmpq %rax, %rdi
cmovbq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: getCancels(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>>>>>, int)
vector<int> getCancels(vector<int> choices, vector<vector<pair<int, int>>> selections, int f)
{
    int N = 3 * f + 1;
    vector<int> cancels(N, -2);
    // compute cancels for each replica
    // OLD // rule is: order by lowest to highest proposal, and take value 2*f
    // NEW RULE (simpler): if Prep0 has a non-faulty proposal, Cancel 0, otherwise Cancel 1
    for (unsigned i = 0; i < N; i++)
    {
        if (choices[i] == -2)
            continue;       // faulty node
        int count_zero = 0; // try to Cancel 0 (NEW RULE)
        //vector<int> responses;
        //responses.push_back(choices[i]); // own choice counts
        //for (unsigned j = 0; j < selections[i].size(); j++)
        //    responses.push_back(selections[i][j].second);
        ////cout << "RESPONSES FOR I=" << i << endl;
        ////printv(responses);
        //sort(responses.begin(), responses.end());
        //printv(responses);
        //int cancel = responses[2 * f - 1];
        for (unsigned j = 0; j < selections[i].size(); j++)
            if (selections[i][j].second == 0)
                count_zero++;
        if (choices[i] == 0)
            count_zero++;
        int cancel = 1;          // default one
        if (count_zero >= f + 1) // at least one trusted
            cancel = 0;

        ////cout << "cancel = " << cancel << endl;
        cancels[i] = cancel;
        // EXCEPTION: proposal j cannot Cancel more than j (otherwise it just assumes its "faultyness", what is absurd)
        if (i == 0)
            cancels[i] = 0; // FORCE. could do same for i=1 (but only two, so that's fine already)
    }

    return cancels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leal (%rbx,%rbx,2), %r13d
leal 0x1(%r13), %eax
movslq %eax, %rsi
leaq -0x30(%rbp), %rdx
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
leaq -0x29(%rbp), %rcx
callq 0x4c92
incl %r13d
je 0x2c34
movl %r13d, %eax
xorl %ecx, %ecx
movq (%r12), %rdx
movl (%rdx,%rcx,4), %edx
cmpl $-0x2, %edx
je 0x2c2c
movq (%r14), %rdi
leaq (%rcx,%rcx,2), %r8
movq (%rdi,%r8,8), %rsi
movq 0x8(%rdi,%r8,8), %rdi
subq %rsi, %rdi
je 0x2c08
sarq $0x3, %rdi
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpl $0x1, 0x4(%rsi,%r9,8)
adcl $0x0, %r8d
incq %r9
movl %r9d, %r10d
cmpq %r10, %rdi
ja 0x2bf1
jmp 0x2c0b
xorl %r8d, %r8d
cmpl $0x1, %edx
adcl $0x0, %r8d
cmpl %ebx, %r8d
setle %dl
movq (%r15), %rsi
testq %rcx, %rcx
setne %dil
andb %dl, %dil
movzbl %dil, %edx
movl %edx, (%rsi,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jne 0x2bc6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
leal (%rcx,%rcx,2), %eax
incl %eax
je 0x2e1c
movq %rsi, %r14
movl %eax, %eax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
movq 0x635b(%rip), %rbx      # 0x8fd8
leaq 0x33ad(%rip), %r13      # 0x6031
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x33f6(%rip), %rsi      # 0x6089
callq 0x2170
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20d0
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
leaq 0x33d0(%rip), %rsi      # 0x6085
callq 0x2170
movq -0x40(%rbp), %rbx
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x2210
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2170
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x2210
movl $0x4, %edx
movq %rax, %rdi
leaq 0x338e(%rip), %rsi      # 0x608c
callq 0x2170
movq (%r14), %rcx
movq %r12, -0x30(%rbp)
leaq (%r12,%r12,2), %rdx
movq (%rcx,%rdx,8), %rax
cmpq %rax, 0x8(%rcx,%rdx,8)
je 0x2dac
movl $0x1, %ebx
movq -0x30(%rbp), %rcx
leaq (,%rcx,8), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rcx, -0x50(%rbp)
xorl %r12d, %r12d
movl 0x4(%rax,%r12,8), %esi
movq 0x6293(%rip), %rdi      # 0x8fd8
callq 0x2210
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x32d5(%rip), %rsi      # 0x6031
callq 0x2170
movq (%r14), %rax
movq -0x50(%rbp), %r13
movq (%rax,%r13), %rax
movl (%rax,%r12,8), %esi
movq %r15, %rdi
leaq 0x3317(%rip), %r15      # 0x6091
callq 0x2210
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movl %ebx, %r12d
movq (%r14), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebx
cmpq %r12, %rcx
ja 0x2d39
movl $0x9, %edx
movq 0x6220(%rip), %rbx      # 0x8fd8
movq %rbx, %rdi
leaq 0x32d2(%rip), %rsi      # 0x6094
callq 0x2170
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %r12
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
incq %r12
cmpq -0x38(%rbp), %r12
leaq 0x321b(%rip), %r13      # 0x6031
jne 0x2c84
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: verifyFastCommits(std::vector<int, std::allocator<int>>, 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>>>>>)
vector<int> verifyFastCommits(vector<int> cancels, vector<int> choices, vector<vector<pair<int, int>>> selections)
{
    int N = choices.size();
    int f = (N - 1) / 3;
    vector<int> fast(N, -2);
    for (unsigned i = 0; i < N; i++)
    {
        int sum_zeros = 0;
        int sum_ones = 0;
        if (choices[i] != -2) // exists
        {
            if (cancels[i] == 0)
                sum_zeros++;
            if (cancels[i] == 1)
                sum_ones++;
            for (unsigned k = 0; k < selections[i].size(); k++)
            {
                if (selections[i][k].second == 0)
                    sum_zeros++;
                if (selections[i][k].second == 1)
                    sum_ones++;
            }
        }
        // compute fast commits
        if (sum_ones >= 2 * f + 1) // fast
            fast[i] = 1;
        if (sum_zeros >= f + 1) // fast
            fast[i] = 0;
    }
    return fast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq 0x8(%rdx), %r14
subq (%rdx), %r14
shrq $0x2, %r14
movslq %r14d, %r13
leal -0x1(%r14), %ebx
leaq -0x44(%rbp), %rdx
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
leaq -0x29(%rbp), %rcx
movq %rdi, -0x38(%rbp)
movq %r13, %rsi
callq 0x4c92
cmpl $0x1, %r13d
jb 0x2f40
movslq %ebx, %rax
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
movq (%r12), %rcx
leal (%rax,%rax), %edx
movq -0x38(%rbp), %rsi
movq (%rsi), %rsi
movl %r14d, %edi
xorl %r8d, %r8d
cmpl $-0x2, (%rcx,%r8,4)
movl $0x0, %r9d
movl $0x0, %r10d
je 0x2f1a
movq (%r15), %r9
movl (%r9,%r8,4), %r11d
xorl %r9d, %r9d
testl %r11d, %r11d
sete %r9b
xorl %r10d, %r10d
cmpl $0x1, %r11d
sete %r10b
movq -0x40(%rbp), %r11
movq (%r11), %r14
leaq (%r8,%r8,2), %r12
movq (%r14,%r12,8), %r11
movq 0x8(%r14,%r12,8), %r12
subq %r11, %r12
je 0x2f1a
sarq $0x3, %r12
xorl %r14d, %r14d
movl 0x4(%r11,%r14,8), %r13d
cmpl $0x1, %r13d
adcl $0x0, %r9d
xorl %ebx, %ebx
cmpl $0x1, %r13d
sete %bl
addl %ebx, %r10d
incq %r14
movl %r14d, %ebx
cmpq %rbx, %r12
ja 0x2ef6
cmpl %edx, %r10d
jle 0x2f27
movl $0x1, (%rsi,%r8,4)
cmpl %eax, %r9d
jle 0x2f34
movl $0x0, (%rsi,%r8,4)
incq %r8
cmpq %rdi, %r8
jne 0x2ea7
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x0, 0x74(%rdi)
movq 0x4b22(%rip), %rbx      # 0xcfd8
leaq 0x15fb(%rip), %rsi      # 0x9ab8
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movl 0x74(%r14), %ecx
cmpl $0x19, %eax
jne 0x8521
incl %ecx
movl %ecx, 0x74(%r14)
jmp 0x8562
decl %ecx
movl %ecx, 0x74(%r14)
leaq 0x159f(%rip), %rsi      # 0x9acd
movl $0x10, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
leaq 0x1575(%rip), %rsi      # 0x9ade
movl $0x20, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
movl $0x14, %esi
callq *0x10(%rax)
leaq 0x1505(%rip), %rsi      # 0x9ab8
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movl 0x74(%r14), %ecx
cmpl $0x2d, %eax
jne 0x8617
incl %ecx
movl %ecx, 0x74(%r14)
jmp 0x865c
decl %ecx
movl %ecx, 0x74(%r14)
leaq 0x14db(%rip), %rsi      # 0x9aff
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movl 0x74(%r14), %ecx
cmpl $0x2, %ecx
jne 0x86a1
leaq 0x13c1(%rip), %rsi      # 0x9a29
movl $0x2b, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Naomi1745698[P]BigPrac/test.cpp
// Function: test::~test()
test::~test(){
	delete playerShip;
	delete playerShip1;	
	delete planet1;
	delete meteor1;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x86c0
movq %r14, %rdi
callq 0x35c2
movl $0x40, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x86de
movq %r14, %rdi
callq 0x35c2
movl $0x40, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x86fc
movq %r14, %rdi
callq 0x30b2
movl $0x38, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x871a
movq %r14, %rdi
callq 0x30b2
movl $0x38, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x873f
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x875d
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/main.cpp
// Function: main
int main() {

  // A list of futures.
  std::list<std::future<void>> list;

  // Producer and consumer thread pools.
  thread::pool::parameterized_pool_t<1, 0> pool_of_consumers(std::thread::hardware_concurrency() + 1);

  // Scheduling the producers.
  for (size_t i = 0; i < work_to_spawn; ++i) {
    list.push_back(pool_of_consumers.schedule(static_void_function));
  }
  
  // Counting the start time.
  auto start = std::chrono::high_resolution_clock::now();

  // Waiting for the consumers to complete.
  for (std::future<void>& future : list) {
    future.wait();
  }

  // Measuring and dumping the elapsed time.
  auto end = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> diff = end - start;
  std::cout << "Elasped time : " << diff.count() << " ms" << std::endl;

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
callq 0x32d0
leal 0x1(%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x37d4
movl $0x2710, %r13d          # imm = 0x2710
leaq 0x15d(%rip), %r14       # 0x379d
movq %rsp, %r15
leaq 0x30(%rsp), %r12
xorl %ebp, %ebp
leaq 0x18(%rsp), %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x389c
movl $0x20, %edi
callq 0x3240
movapd (%rsp), %xmm0
movq %rbp, 0x8(%rsp)
movupd %xmm0, 0x10(%rax)
movq %rbp, (%rsp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3060
incq 0x28(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3699
callq 0x3af4
decq %r13
jne 0x364f
callq 0x3050
movq %rax, %r14
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x36bc
leaq 0x10(%r15), %rdi
callq 0x3a58
jmp 0x36a9
callq 0x3050
movq %rax, %rbx
movq 0x88ed(%rip), %rdi      # 0xbfb8
leaq 0x39ee(%rip), %rsi      # 0x70c0
movl $0xf, %edx
callq 0x3280
subq %r14, %rbx
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
divsd 0x3919(%rip), %xmm0     # 0x7008
movq 0x88c2(%rip), %rdi      # 0xbfb8
callq 0x3310
movq %rax, %rbx
leaq 0x39cb(%rip), %rsi      # 0x70d0
movl $0x3, %edx
movq %rax, %rdi
callq 0x3280
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x30(%rsp), %rdi
callq 0x3a70
leaq 0x18(%rsp), %rdi
callq 0x3b64
xorl %eax, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3777
jmp 0x376a
jmp 0x376a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3a70
leaq 0x18(%rsp), %rdi
callq 0x3b64
movq %rbx, %rdi
callq 0x3390
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x376d
callq 0x3af4
jmp 0x376d
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rdx, (%rcx)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x525a
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x51ea
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x3906
movq 0x86ba(%rip), %rax      # 0xbfb0
cmpb $0x0, (%rax)
je 0x3901
incl 0x8(%r15)
jmp 0x3906
lock
incl 0x8(%r15)
movq $0x0, 0x28(%rsp)
movl $0x10, %edi
callq 0x3240
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x20(%rsp)
leaq 0x338a(%rip), %rax      # 0x6cb6
movq %rax, 0x38(%rsp)
leaq 0x339e(%rip), %rax      # 0x6cd6
movq %rax, 0x30(%rsp)
leaq 0x18(%r14), %rdi
callq 0x5f9c
testq %rax, %rax
je 0x3972
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x621c
testb %al, %al
je 0x3972
movq 0x288(%r14), %rdi
movb $0x1, %bpl
movl $0x1, %esi
callq 0x5f2e
jmp 0x3974
xorl %ebp, %ebp
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x398d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testb %bpl, %bpl
je 0x39b1
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x39a1
callq 0x3af4
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r15
leaq 0x3df4(%rip), %rsi      # 0x77b9
movq %rax, %rdi
callq 0x3290
movq 0x85fc(%rip), %rsi      # 0xbfd0
movq 0x85c5(%rip), %rdx      # 0xbfa0
movq %r15, %rdi
callq 0x3380
movq %rax, %r14
jmp 0x3a2a
movq %rax, %r14
movq %r15, %rdi
callq 0x3180
jmp 0x3a2a
jmp 0x3a4f
movq %rax, %r14
testq %r15, %r15
je 0x3a2a
movq %r15, %rdi
callq 0x3af4
jmp 0x3a2a
movq %rax, %r14
jmp 0x3a38
movq %rax, %r14
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x3a2a
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3a38
callq 0x3af4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3a47
callq 0x3af4
movq %r14, %rdi
callq 0x3390
movq %rax, %rdi
callq 0x3ae9
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %eax, %eax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x28(%rdi)
movl $0x60, %eax
movq $0x0, (%rdi,%rax)
addq $0x10, %rax
cmpq $0x260, %rax            # imm = 0x260
jne 0x3ea7
leaq 0x58(%rdi), %rcx
movq $0x0, 0x25c(%rdi)
movb $0x0, 0x258(%rdi)
movq $0x0, 0x38(%rdi)
leaq 0x40(%rdi), %rax
movq $0x20, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movl $0x58, %ecx
movq $0x0, (%rdi,%rcx)
addq $0x10, %rcx
cmpq $0x258, %rcx            # imm = 0x258
jne 0x3eee
movq $0x0, 0x50(%rdi)
movq %rax, 0x30(%rdi)
movq %rsi, %rax
shrq $0x5, %rax
andl $0x1f, %esi
cmpq $0x1, %rsi
sbbq $-0x1, %rax
movq %rax, %rsi
jmp 0x401e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x3f89
movq 0x8(%r14), %r15
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x3f6d
movq $0x0, (%rax)
leaq -0x8(%r15), %r12
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r14, %rdi
callq 0x32a0
movq %r12, %r14
testq %r15, %r15
jne 0x3f59
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3fac
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3fac
movq %rax, %r14
callq 0x32a0
movq 0x10(%r14), %rax
movq %r14, %rdi
jmp 0x3f96
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x3fd2
movq 0x438(%rdi), %r14
cmpb $0x1, 0x441(%rdi)
jne 0x3fca
callq 0x32a0
movq %r14, %rdi
testq %r14, %r14
jne 0x3fb5
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3ff2
cmpq $0x0, 0x20(%rbx)
je 0x3ffe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x32a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x30cf(%rip), %rdi      # 0x70d4
leaq 0x30d2(%rip), %rsi      # 0x70de
leaq 0x31b8(%rip), %rcx      # 0x71cb
movl $0xe1f, %edx            # imm = 0xE1F
callq 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::details::Semaphore::Semaphore(int)
Semaphore(int initialCount = 0)
	{
		assert(initialCount >= 0);
		int rc = sem_init(&m_sema, 0, static_cast<unsigned int>(initialCount));
		assert(rc == 0);
		(void)rc;
	}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x4688
movl %esi, %edx
xorl %esi, %esi
callq 0x31c0
testl %eax, %eax
jne 0x46a7
popq %rax
retq
leaq 0x2a75(%rip), %rdi      # 0x7104
leaq 0x2a80(%rip), %rsi      # 0x7116
leaq 0x2af7(%rip), %rcx      # 0x7194
movl $0xb1, %edx
callq 0x3150
leaq 0x2b15(%rip), %rdi      # 0x71c3
leaq 0x2a61(%rip), %rsi      # 0x7116
leaq 0x2ad8(%rip), %rcx      # 0x7194
movl $0xb3, %edx
callq 0x3150