LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::move_Messages(Folder*)
void Folder::move_Messages(Folder* f)
{
	msgs = std::move(f->msgs); // move the set from f to this Folder
	f->msgs.clear(); // ensure that destroying f is harmless
	for (auto m : msgs) {  // for each Message in this Folder
		m->remFldr(f);     // remove the pointer to the old Folder
		m->addFldr(this);  // insert pointer to this Folder
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2ec0
movq %rbx, -0x38(%rbp)
movq %rbx, %rdi
callq 0x3116
movq 0x18(%r14), %r15
leaq 0x8(%r14), %rbx
cmpq %rbx, %r15
je 0x25e0
leaq -0x30(%rbp), %r12
movq 0x20(%r15), %r13
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x20, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3c2c
movq %r13, %rdi
movq %rax, %rsi
callq 0x3cb4
movq %r14, -0x30(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x314e
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
cmpq %rbx, %rax
jne 0x259b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::move_Folders(Message*)
void Message::move_Folders(Message* m)
{
	folders = std::move(m->folders); // uses set move assignment
	for (auto f : folders) {  // for each Folder
		f->remMsg(m);    // remove the old Message from the Folder
		f->addMsg(this); // add this Message to that Folder
	}
	m->folders.clear();  // ensure that destroying m is harmless
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq %rsi, -0x40(%rbp)
addq $0x20, %rsi
addq $0x20, %rdi
movq %rsi, -0x38(%rbp)
callq 0x2f32
movq 0x38(%r15), %r12
leaq 0x28(%r15), %r14
cmpq %r14, %r12
je 0x27d0
leaq -0x30(%rbp), %r13
movq 0x20(%r12), %rbx
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3d3a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3dc2
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2f96
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
cmpq %r14, %rax
jne 0x278e
movq -0x38(%rbp), %rdi
callq 0x3712
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/./write.h
// Function: void write_float<double>(Interpreter::State const&, double const&, Stream&)
void write_float
  (const Interpreter::State& state, const T& input, Stream& output) {
  switch (state.format) {
  case Term::INTEGER:
    throw std::runtime_error
      ("Float values cannot be written in integer format.");
  case Term::FLOAT:
    switch (state.width) {
    case 32:
      write_float_value<float>(state.endianness, input, output);
      break;
    case 64:
      write_float_value<double>(state.endianness, input, output);
      break;
    default:
      IMPOSSIBLE("invalid float bit width");
    }
    break;
  case Term::UNICODE:
    throw std::runtime_error
      ("Float values cannot be written in Unicode format.");
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl 0xc(%rdi), %eax
cmpl $0x1, %eax
je 0x53a6
cmpl $0x2, %eax
je 0x53e5
testl %eax, %eax
jne 0x53dc
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6e4d(%rip), %rsi      # 0xc1e9
movq %rax, %rdi
callq 0x30c0
jmp 0x5401
movl (%rdi), %eax
cmpl $0x40, %eax
je 0x53c7
cmpl $0x20, %eax
jne 0x5417
cvtsd2ss (%rsi), %xmm0
movl 0x4(%rdi), %esi
movq %rsp, %rdi
movss %xmm0, (%rdi)
callq 0x663f
jmp 0x53dc
movl 0x4(%rdi), %eax
movsd (%rsi), %xmm0
movq %rsp, %rdi
movsd %xmm0, (%rdi)
movl %eax, %esi
callq 0x6694
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6e22(%rip), %rsi      # 0xc21b
movq %rax, %rdi
callq 0x30c0
movq 0xcbe8(%rip), %rsi      # 0x11ff0
movq 0xcb79(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6d4e(%rip), %rsi      # 0xc179
leaq 0x6d5a(%rip), %rdx      # 0xc18c
leaq 0x71ff(%rip), %rcx      # 0xc638
movq %rsp, %rdi
callq 0x5f70
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e0
xorl %ebp, %ebp
movq 0xcb60(%rip), %rsi      # 0x11fb8
movq 0xcb41(%rip), %rdx      # 0x11fa0
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5485
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x5493
jmp 0x549b
jmp 0x5490
jmp 0x5490
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/./write.h
// Function: void write_integer_value<unsigned int, long>(Term::Endianness, long const&, Stream&)
void write_integer_value
  (const Term::Endianness endianness, const I& input, Stream& output) {
  typedef std::numeric_limits<decltype(input)> input_limits;
  typedef std::numeric_limits<O> type_limits;
  if (input < type_limits::min() || input > type_limits::max())
    throw std::runtime_error
      (join("Value exceeds range of ", type_name<O>::value, " integer."));
  const O buffer(input);
  endian_copy(buffer, endianness, output);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rcx
movq %rcx, %rsi
shrq $0x20, %rsi
jne 0x5b85
movl %edi, %eax
movq %rsp, %rdi
movl %ecx, (%rdi)
movl %eax, %esi
callq 0x6358
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6625(%rip), %rsi      # 0xc1be
leaq 0xc680(%rip), %rdx      # 0x12220
leaq 0x65ad(%rip), %rcx      # 0xc154
movq %rsp, %rdi
callq 0x6169
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0xc42a(%rip), %rsi      # 0x11ff0
movq 0xc3bb(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5bf3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x5bfd
jmp 0x5c05
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/vendor/utf8/checked.h
// Function: unsigned char* utf8::append<unsigned char*>(unsigned int, unsigned char*)
octet_iterator append(uint32_t cp, octet_iterator result)
    {
        if (!utf8::internal::is_code_point_valid(cp))
            throw invalid_code_point(cp);

        if (cp < 0x80)                        // one octet
            *(result++) = static_cast<uint8_t>(cp);
        else if (cp < 0x800) {                // two octets
            *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
        }
        else if (cp < 0x10000) {              // three octets
            *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
        }
        else {                                // four octets
            *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
            *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
        }
        return result;
    }

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x60aa
movl %ebx, %eax
andl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x60aa
cmpl $0x7f, %ebx
ja 0x602f
movb %bl, (%rsi)
incq %rsi
jmp 0x60a5
movl %ebx, %eax
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x604f
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x1(%rsi)
addq $0x2, %rsi
jmp 0x60a5
cmpl $0xffff, %ebx           # imm = 0xFFFF
ja 0x6079
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %ebx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x2(%rsi)
addq $0x3, %rsi
jmp 0x60a5
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsi)
movl %ebx, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %ebx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x3(%rsi)
addq $0x4, %rsi
movq %rsi, %rax
popq %rbx
retq
movl $0x10, %edi
callq 0x3100
leaq 0xba65(%rip), %rcx      # 0x11b20
movq %rcx, (%rax)
movl %ebx, 0x8(%rax)
leaq 0xba30(%rip), %rsi      # 0x11af8
movq 0xbef9(%rip), %rdx      # 0x11fc8
movq %rax, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/./write.h
// Function: void endian_copy<unsigned int>(unsigned int const&, Term::Endianness, Stream&)
void endian_copy
  (const T& value, const Term::Endianness endianness, Stream& output) {
  using namespace std;
  array<char, sizeof(T)> buffer;
  const auto begin = reinterpret_cast<const char*>(&value),
    end = begin + sizeof(T);
  copy(begin, end, buffer.begin());
  if (endianness != Term::NATIVE && endianness != platform_endianness())
    reverse(buffer.begin(), buffer.end());
  output.write(buffer.begin(), buffer.end());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdi), %eax
movl %eax, 0x4(%rsp)
cmpl $0x2, %esi
jb 0x638b
leaq 0x7(%rsp), %rax
xorl %ecx, %ecx
movb 0x4(%rsp,%rcx), %dl
movb (%rax), %sil
movb %sil, 0x4(%rsp,%rcx)
movb %dl, (%rax)
incq %rcx
decq %rax
cmpq $0x2, %rcx
jne 0x6371
xorl %r14d, %r14d
movsbl 0x4(%rsp,%r14), %esi
incq %r14
movq %rbx, %rdi
callq 0x6cc0
cmpq $0x4, %r14
jne 0x638e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/Stream.cpp
// Function: Stream::~Stream()
Stream::~Stream() {
  const auto extra = buffer.size() % 8;
  if (extra != 0)
    for (int i = 0; i < (8 - extra); ++i)
      buffer.push_back(false);
  flush();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movl 0x10(%rdi), %r12d
subl 0x8(%rdi), %r12d
andl $0x7, %r12d
je 0x6bf3
orq $-0x8, %r12
leaq 0x7(%rsp), %r15
movb $0x0, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6dba
incq %r12
jne 0x6bde
movq %rbx, %rdi
callq 0x6c26
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6c0f
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6c1d
movq %rax, %rdi
callq 0x54a3
nop
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/Stream.cpp
// Function: Stream::write(char)
void Stream::write(const char raw) {
  const uint8_t octet = raw;
  if (buffer.empty()) {
    stream.put(octet);
  } else {
    for (int i = 7; i >= 0; --i)
      buffer.push_back(bool(octet & (1 << i)));
  }
  flush();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x6d08
leaq 0x8(%rbx), %r14
movzbl %sil, %ebp
movl $0x7, %r12d
leaq 0xf(%rsp), %r15
btl %r12d, %ebp
setb 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6dba
addl $-0x1, %r12d
jb 0x6cec
jmp 0x6d14
movq (%rbx), %rdi
movsbl %sil, %esi
callq 0x3030
movq %rbx, %rdi
callq 0x6c26
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/Term.cpp
// Function: Term::Term(Term::Type, void const*)
Term::Term(const Type type, const void* const source = 0) : type(type) {
  switch (type) {
  case NOOP:
    break;
  case PUSH:
  case POP:
    break;
  case WRITE_SIGNED:
    value.as_signed = *static_cast<const Signed*>(source);
    break;
  case WRITE_UNSIGNED:
    value.as_unsigned = *static_cast<const Unsigned*>(source);
    break;
  case WRITE_DOUBLE:
    value.as_double = *static_cast<const Double*>(source);
    break;
  default:
    IMPOSSIBLE("invalid Term type");
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, (%rdi)
cmpl $0x5, %esi
ja 0x6f4c
movl %esi, %eax
leaq 0x5370(%rip), %rcx      # 0xc298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
jmp 0x6f43
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x5219(%rip), %rsi      # 0xc179
leaq 0x5349(%rip), %rdx      # 0xc2b0
leaq 0x56ca(%rip), %rcx      # 0xc638
movq %rsp, %rdi
callq 0x6fff
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e0
xorl %ebp, %ebp
movq 0xb02b(%rip), %rsi      # 0x11fb8
movq 0xb00c(%rip), %rdx      # 0x11fa0
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6fba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x6fc4
jmp 0x6fcc
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/main.cpp
// Function: main
int main(int argc, char** argv) try {
  using namespace std;
  auto parsed_arguments = parse_arguments(argc, argv);
  const auto inputs = move(get<0>(parsed_arguments));
  const auto output = move(get<1>(parsed_arguments));
  vector<Term> terms;
  Interpreter interpreter(*output);
  for (const auto& input : inputs) try {
    parse(*input.stream, interpreter);
  } catch (...) {
    ::throw_with_nested(runtime_error(join("In input ", input.name, ":")));
  }
} catch (const std::exception& exception) {
  report(exception);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x58(%rsp), %rdi
callq 0x70d0
leaq 0x60(%rsp), %rbx
movq -0x8(%rbx), %rsi
movq (%rbx), %r14
movq %r14, 0x30(%rsp)
movq 0x8(%rbx), %r13
movq %r13, 0x38(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rsi, 0x8(%rsp)
movq %rax, -0x8(%rbx)
leaq 0x78(%rsp), %rdi
callq 0x477c
cmpq %r13, %r14
je 0x81cc
leaq 0x78(%rsp), %r15
leaq 0x10(%rsp), %rbp
leaq 0x48(%rsp), %r12
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x86d8
addq $0x10, %r14
cmpq %r13, %r14
jne 0x8156
jmp 0x81cc
movq %rax, %rdi
callq 0x30e0
movq %rbp, %rdi
leaq 0x4556(%rip), %rsi      # 0xc6d5
movq %r14, %rdx
leaq 0x4556(%rip), %rcx      # 0xc6df
callq 0x84c1
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3310
movq %r12, %rdi
callq 0x843f
movq %r12, %rdi
callq 0x33e8
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x81c5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
callq 0x3330
jmp 0x8162
leaq 0x98(%rsp), %rdi
callq 0x54ae
leaq 0x78(%rsp), %rdi
callq 0x6bb8
leaq 0x8(%rsp), %rdi
callq 0x78b6
leaq 0x30(%rsp), %rdi
callq 0x78dc
movq %rbx, %rdi
callq 0x78dc
leaq 0x58(%rsp), %rdi
callq 0x78b6
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x8266
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x33e8
jmp 0x823d
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x8261
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x8261
movq %rdx, %r15
movq %rax, %r14
callq 0x3330
leaq 0x98(%rsp), %rdi
callq 0x54ae
leaq 0x78(%rsp), %rdi
callq 0x6bb8
jmp 0x8285
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x78b6
leaq 0x30(%rsp), %rdi
callq 0x78dc
movq %rbx, %rdi
callq 0x78dc
leaq 0x58(%rsp), %rdi
callq 0x78b6
jmp 0x82b3
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x82e2
movq %r14, %rdi
callq 0x30e0
movq %rax, %rdi
xorl %esi, %esi
callq 0x82f2
callq 0x3330
movl $0x1, %eax
jmp 0x820b
movq %rax, %r14
callq 0x3330
movq %r14, %rdi
callq 0x3380
movq %rax, %rdi
callq 0x54a3
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/main.cpp
// Function: report(std::exception const&, int)
void report(const std::exception& exception, int depth) {
  std::cerr << std::string(depth * 2, ' ') << exception.what() << '\n';
  try {
    ::rethrow_if_nested(exception);
  } catch (const std::exception& exception) {
    report(exception, depth + 1);
  } catch (...) {
    return;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %eax
movslq %eax, %rsi
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x10(%rsp), %rdi
movl $0x20, %edx
callq 0x3280
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x9cb5(%rip), %rdi      # 0x11fe8
callq 0x3270
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %rax, %rax
je 0x8364
movq %rax, %r12
movq %rax, %rdi
callq 0x30f0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3270
jmp 0x837e
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x3350
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x3270
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x83aa
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x9c1f(%rip), %rsi      # 0x11fd0
leaq 0x9880(%rip), %rdx      # 0x11c38
movq %r14, %rdi
movq $-0x2, %rcx
callq 0x3260
testq %rax, %rax
je 0x83d4
movq %rax, %rdi
callq 0x8692
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %r14d
jne 0x83ff
incl %ebx
movq %rax, %rdi
movl %ebx, %esi
callq 0x82f2
callq 0x3330
jmp 0x83d4
movq %rax, %rbx
callq 0x3330
jmp 0x8437
movq %rax, %rdi
callq 0x54a3
movq %rax, %rbx
jmp 0x8437
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x8437
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/parse.cpp
// Function: parse(std::istream&, Interpreter&)
void parse(std::istream& input, Interpreter& interpreter) {
  unsigned int line = 1;
  unsigned int column = 0;
  try {
    parse_internal(input, interpreter, line, column);
  } catch (...) {
    ::throw_with_nested(std::runtime_error
      (join("At line ", line, ", column ", column, ":")));
  }
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0xc(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
callq 0x87bb
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x30e0
leaq 0x40f1(%rip), %rsi      # 0xc7fe
leaq 0x40f3(%rip), %rcx      # 0xc807
leaq 0x3fc4(%rip), %r9       # 0xc6df
leaq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %r8
callq 0x997b
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3310
leaq 0x10(%rsp), %rdi
callq 0x843f
leaq 0x10(%rsp), %rdi
callq 0x33e8
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x876d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3210
callq 0x3330
jmp 0x86f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x33e8
jmp 0x8786
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87a6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x87a6
movq %rax, %rbx
callq 0x3330
movq %rbx, %rdi
callq 0x3380
movq %rax, %rdi
callq 0x54a3
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/parse.cpp
// Function: (anonymous namespace)::parse_width(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned long parse_width(const std::string& token) {
  const auto begin = token.c_str() + 1;
  char* boundary;
  const auto width = std::strtoul(begin, &boundary, 10);
  if (boundary != token.c_str() + token.size())
    throw std::runtime_error
      (join("Invalid unsigned type: '", token, "'."));
  if (width == 0 || width > 64)
    throw std::runtime_error
      (join("Unsupported width of unsigned type: '", token, "'."));
  return width;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
incq %rdi
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
movl $0xa, %edx
callq 0x3090
movq (%r14), %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, (%rbx)
jne 0x95fa
leaq -0x41(%rax), %rcx
cmpq $-0x41, %rcx
jbe 0x964c
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x32db(%rip), %rsi      # 0xc8e9
leaq 0x3022(%rip), %rcx      # 0xc637
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xa21e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x89b5(%rip), %rsi      # 0x11ff0
movq 0x8946(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x969c
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x32a2(%rip), %rsi      # 0xc902
leaq 0x2fd0(%rip), %rcx      # 0xc637
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xa309
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x8963(%rip), %rsi      # 0x11ff0
movq 0x88f4(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x96a0
jmp 0x96c5
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x96be
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x96c8
jmp 0x96d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/parse.cpp
// Function: (anonymous namespace)::write_integer_term(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
Term write_integer_term(const std::string& token, int base) {
  const bool has_sign = token[0] == '-' || token[0] == '+';
  char* boundary;
  const auto begin = token.c_str(), end = begin + token.size();
  if (has_sign) {
    Term::Signed value = std::strtoll(begin, &boundary, base);
    if (boundary != end)
      throw std::runtime_error(join("Invalid base-", base,
        " signed integer literal: \"", token, "\""));
    return Term::write(value);
  } else {
    Term::Unsigned value = std::strtoull(begin, &boundary, base);
    if (boundary != end)
      throw std::runtime_error(join("Invalid base-", base,
        " unsigned integer literal: \"", token, "\""));
    return Term::write(value);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %edx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movq (%rdi), %rdi
movb (%rdi), %al
cmpb $0x2d, %al
jne 0x96fd
movq 0x8(%r14), %r15
addq %rdi, %r15
jmp 0x9708
movq 0x8(%r14), %r15
addq %rdi, %r15
cmpb $0x2b, %al
jne 0x972c
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x3060
cmpq %r15, (%rbx)
jne 0x9750
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6fea
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x32a0
cmpq %r15, (%rbx)
jne 0x97ae
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6fe0
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x313f(%rip), %rsi      # 0xc8a3
leaq 0x3146(%rip), %rcx      # 0xc8b1
leaq 0x3158(%rip), %r9       # 0xc8ca
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %r8
callq 0x9e24
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x8853(%rip), %rsi      # 0x11ff0
movq 0x87e4(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x980a
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x30e1(%rip), %rsi      # 0xc8a3
leaq 0x3103(%rip), %rcx      # 0xc8cc
leaq 0x30fa(%rip), %r9       # 0xc8ca
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %r8
callq 0x9f29
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x87f5(%rip), %rsi      # 0x11ff0
movq 0x8786(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x980e
jmp 0x9833
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x982c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x9836
jmp 0x983e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/evincarofautumn[P]protodata/vendor/utf8/checked.h
// Function: unsigned int utf8::next<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
uint32_t next(octet_iterator& it, octet_iterator end)
    {
        uint32_t cp = 0;
        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
        switch (err_code) {
            case internal::UTF8_OK :
                break;
            case internal::NOT_ENOUGH_ROOM :
                throw not_enough_room();
            case internal::INVALID_LEAD :
            case internal::INCOMPLETE_SEQUENCE :
            case internal::OVERLONG_SEQUENCE :
                throw invalid_utf8(*it);
            case internal::INVALID_CODE_POINT :
                throw invalid_code_point(cp);
        }
        return cp;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
callq 0xa9df
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
jb 0xa96c
cmpl $0x5, %eax
je 0xa991
cmpl $0x1, %eax
je 0xa9b5
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movl $0x10, %edi
callq 0x3100
movq (%rbx), %rcx
movb (%rcx), %cl
leaq 0x73ce(%rip), %rdx      # 0x11d50
movq %rdx, (%rax)
movb %cl, 0x8(%rax)
leaq 0x7371(%rip), %rsi      # 0x11d00
jmp 0xa9d0
movl $0x10, %edi
callq 0x3100
movl 0xc(%rsp), %ecx
leaq 0x717a(%rip), %rdx      # 0x11b20
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
leaq 0x7145(%rip), %rsi      # 0x11af8
jmp 0xa9d0
movl $0x8, %edi
callq 0x3100
leaq 0x7362(%rip), %rcx      # 0x11d28
movq %rcx, (%rax)
leaq 0x7318(%rip), %rsi      # 0x11ce8
movq 0x75f1(%rip), %rdx      # 0x11fc8
movq %rax, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/threads/part1/Hello2.cpp
// Function: main
int main(){
    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([](){
            std::cout << "Hello from thread " << std::this_thread::get_id() << std::endl;
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x10(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
movl $0x5, %ebp
leaq 0x2adb(%rip), %r12      # 0x3d88
leaq 0x8(%rsp), %r15
movq %rsp, %r14
vmovaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq $0x0, (%rsp)
movl $0x10, %edi
callq 0x1100
movq %r12, (%rax)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12f8
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x143a
cmpq $0x0, (%rsp)
jne 0x1379
decl %ebp
jne 0x12c1
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x132b
movq %rbx, %rdi
callq 0x1130
addq $0x8, %rbx
jmp 0x1318
leaq 0x10(%rsp), %rdi
callq 0x1406
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1364
jmp 0x1364
movq 0x8(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x1367
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1367
cmpq $0x0, (%rsp)
jne 0x1379
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1406
movq %rbx, %rdi
callq 0x1140
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::usage_error(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void usage_error(const char* argv0, const std::string& usage_str, const std::string& parse_err, const std::string& prefix = "Usage: ") {
    const char* basename = std::strrchr(argv0, '/');
    basename = basename? basename+1: argv0;

    std::cerr << basename << ": " << parse_err << "\n";
    std::cerr << prefix << basename << " " << usage_str << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %r13, %r14
testq %r14, %r14
je 0x32a7
movq %r14, %rdi
callq 0x2090
movq 0x7d56(%rip), %rdi      # 0xaff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x32c5
movq 0x7d42(%rip), %rax      # 0xaff0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x21e0
movq 0x7d24(%rip), %r13      # 0xaff0
leaq 0x3e22(%rip), %rsi      # 0x70f5
movl $0x2, %edx
movq %r13, %rdi
callq 0x2170
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x2170
leaq 0x3dd7(%rip), %rsi      # 0x70cf
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r13, %rdi
callq 0x2170
movq %rax, %r15
testq %r14, %r14
je 0x3334
movq %r14, %rdi
callq 0x2090
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x334e
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x21e0
leaq 0x3da1(%rip), %rsi      # 0x70f6
movl $0x1, %edx
movq %r15, %rdi
callq 0x2170
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x2170
leaq 0x3d57(%rip), %rsi      # 0x70cf
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: void to::option::init_<char const (&) [5], std::function<int (int)>>(to::option_flag, char const (&) [5], std::function<int (int)>&&)
void init_(enum option_flag f, Rest&&... rest) {
        is_flag      |= f & flag;
        is_ephemeral |= f & ephemeral;
        is_single    |= f & single;
        is_mandatory |= f & mandatory;
        is_exit      |= f & exit;
        is_stop      |= f & stop;
        is_lax       |= f & lax;
        init_(std::forward<Rest>(rest)...);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl %esi, %eax
andb $0x1, %al
orb %al, 0x68(%rdi)
movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pand 0x351a(%rip), %xmm0     # 0x7020
movd 0x69(%rdi), %xmm1
pxor %xmm2, %xmm2
punpcklbw %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3],xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
por %xmm0, %xmm1
pcmpgtd %xmm2, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pand 0x3501(%rip), %xmm1     # 0x7030
movd %xmm1, 0x69(%rdi)
movl %esi, %eax
andl $0x20, %eax
movzbl 0x6d(%rdi), %edi
orl %eax, %edi
setne 0x6d(%rbx)
movq %rcx, %r14
andl $0x40, %esi
movzbl 0x6e(%rbx), %eax
orl %esi, %eax
setne 0x6e(%rbx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3c64
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3bbc
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bb4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::saved_options::as_arglist() const
arglist as_arglist() const {
        arglist A;

        for (auto& a: *this) A.arg_data.push_back(const_cast<char*>(a.c_str()));
        A.arg_data.push_back(nullptr);
        A.argv = A.arg_data.data();
        A.argc = A.arg_data.size()-1;
        return A;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x44a3
leaq 0x8(%rsp), %r15
movq (%r12), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x511c
addq $0x20, %r12
cmpq %r13, %r12
jne 0x4486
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %r14, %rdi
callq 0x511c
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rax, 0x8(%rbx)
subq %rax, %rcx
shrq $0x3, %rcx
decl %ecx
movl %ecx, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x44e1
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x44f8
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r15, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::option::longest_label[abi:cxx11]() const
std::string longest_label() const {
        const std::string* p = 0;
        for (auto& k: keys) {
            if (!p || k.label.size()>p->size()) p = &k.label;
        }
        return p? *p: std::string{};
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rsi), %rcx
movq 0x28(%rsi), %rdx
cmpq %rdx, %rcx
je 0x4922
xorl %eax, %eax
testq %rax, %rax
je 0x48f6
movq 0x8(%rcx), %rsi
cmpq 0x8(%rax), %rsi
jbe 0x48f9
movq %rcx, %rax
addq $0x28, %rcx
cmpq %rdx, %rcx
jne 0x48e7
testq %rax, %rax
je 0x4922
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3670
jmp 0x4935
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::impl::counted_option::match(to::state&)
maybe_keyarg match(state& st) {
            bool empty_keyset = keys.empty();

            auto try_run = [&](const std::string& label, const state::match_result& mr) -> maybe_keyarg {
                if (run(label, mr.argument)) {
                    st.consume(mr);
                    ++count;
                    return std::make_pair(empty_keyset? nullptr: label.c_str(), mr.argument);
                }
                return nothing;
            };

            if (is_flag) {
                for (auto& k: keys) if (auto m = st.match_flag(k)) return try_run(k.label, *m);
            }
            else if (!empty_keyset) {
                for (auto& k: keys) if (auto m = st.match_option(k)) return try_run(k.label, *m);
            }
            else {
                return try_run("", state::match_result{*st.argv, 1, 0});
            }

            return nothing;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq 0x28(%rsi), %rbp
cmpb $0x1, 0x68(%rsi)
jne 0x567b
cmpq %rbp, %r12
je 0x56a3
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5846
cmpb $0x1, 0x8(%rsp)
je 0x56ab
addq $0x28, %r12
cmpq %rbp, %r12
jne 0x565b
jmp 0x56a3
cmpq %rbp, %r12
je 0x56f0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x58e6
cmpb $0x1, 0x8(%rsp)
je 0x56ab
addq $0x28, %r12
cmpq %rbp, %r12
jne 0x5685
movb $0x0, (%rbx)
jmp 0x576b
movq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5a90
testb %al, %al
je 0x574a
movl 0x18(%rsp), %esi
movq %r15, %rdi
callq 0x57f0
movl 0x1c(%rsp), %eax
addl %eax, 0x10(%r15)
incl 0x70(%r14)
movq (%r12), %rax
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movb $0x1, %al
jmp 0x574c
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x19d0(%rip), %rdx      # 0x70d0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x38ec
movq 0x8(%r15), %rax
movq (%rax), %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5a90
testb %al, %al
je 0x5750
movq %r15, %rdi
movl $0x1, %esi
callq 0x57f0
incl 0x70(%r14)
movq $0x0, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movb $0x1, %al
jmp 0x5752
xorl %eax, %eax
movb %al, (%rbx)
jmp 0x576b
xorl %eax, %eax
movb %al, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x576b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5797
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::shift(unsigned int)
void shift(unsigned n = 1) {
        if (!n) return;

        char** skip = argv;
        while (*skip && n) ++skip, --n;

        argc -= (skip-argv);
        auto p = argv;
        do { *p++ = *skip; } while (*skip++);

        optoff = 0;
    }

// Assembly:
testl %esi, %esi
je 0x5844
movq 0x8(%rdi), %rax
cmpq $0x0, (%rax)
movq %rax, %rcx
je 0x581b
decl %esi
movq %rax, %rcx
addl $-0x1, %esi
setb %dl
cmpq $0x0, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
je 0x581b
testb %dl, %dl
jne 0x5806
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movq (%rdi), %rsi
subl %edx, (%rsi)
xorl %edx, %edx
movq (%rcx,%rdx), %rsi
movq %rsi, (%rax,%rdx)
addq $0x8, %rdx
testq %rsi, %rsi
jne 0x582c
movl $0x0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_flag(to::key const&)
maybe<match_result> match_flag(const key& k) {
        if (k.style==key::compact) {
            if (auto m = match_compact_key(k.label.c_str())) {
                if ((*argv)[optoff+*m]) 
                    return match_result{nullptr, 0, *m};
                else
                    return match_result{nullptr, 1, 0};
            }
        }
        else if (!optoff && k.label==*argv) {
            return match_result{nullptr, 1, 0};
        }

        return nothing;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x20(%rdx)
jne 0x58a7
movq (%rdx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x59e8
cmpb $0x1, (%r15)
jne 0x58c1
movq 0x8(%r14), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
movl 0x10(%r14), %edx
addl %ecx, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpb $0x0, (%rax,%rdx)
sete %dil
cmovnel %ecx, %esi
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movl %edi, 0x10(%rbx)
movl %esi, 0x14(%rbx)
jmp 0x58c4
cmpl $0x0, 0x10(%r14)
jne 0x58c1
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rdx, %rdi
callq 0x2040
testl %eax, %eax
je 0x58d1
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
jmp 0x58c4
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_option(to::key const&)
maybe<match_result> match_option(const key& k) {
        if (k.style==key::compact) {
            if (auto m = match_compact_key(k.label.c_str())) {
                if ((*argv)[optoff+*m])
                    return match_result{*argv+optoff+*m, 1, 0};
                else
                    return match_result{argv[1], 2, 0};
            }
        }
        else if (!optoff && k.label==*argv) {
            return match_result{argv[1], 2, 0};
        }
        else if (!optoff && k.style==key::longfmt) {
            auto keylen = k.label.length();
            if (!std::strncmp(*argv, k.label.c_str(), keylen) && (*argv)[keylen]=='=') {
                return match_result{*argv+keylen+1, 1, 0};
            }
        }

        return nothing;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x20(%rdx)
jne 0x593c
movq (%r15), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x59e8
cmpb $0x1, (%r15)
jne 0x5943
movq 0x8(%r14), %rcx
movq (%rcx), %rax
movl 0x10(%r14), %edx
movl 0xc(%rsp), %esi
leal (%rsi,%rdx), %edi
cmpb $0x0, (%rax,%rdi)
je 0x59a7
addq %rdx, %rax
addq %rsi, %rax
movl $0x1, %ecx
jmp 0x59b0
cmpl $0x0, 0x10(%r14)
je 0x594b
movb $0x0, (%rbx)
jmp 0x59da
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2040
testl %eax, %eax
je 0x59c3
cmpl $0x0, 0x10(%r14)
jne 0x5943
cmpl $0x1, 0x20(%r15)
jne 0x5943
movq (%r15), %rsi
movq 0x8(%r15), %r15
movq 0x8(%r14), %rax
movq (%rax), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x5943
cmpb $0x3d, (%r14,%r15)
jne 0x5943
addq %r15, %r14
incq %r14
movb $0x1, (%rbx)
movq %r14, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
jmp 0x59da
movq 0x8(%rcx), %rax
movl $0x2, %ecx
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movl %ecx, 0x10(%rbx)
movl $0x0, 0x14(%rbx)
jmp 0x59da
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_compact_key(char const*)
maybe<unsigned> match_compact_key(const char* k) {
        unsigned keylen = std::strlen(k);

        unsigned prefix_max = std::min(keylen-1, optoff);
        for (std::size_t l = 0; l<=prefix_max; ++l) {
            if (l && strncmp(*argv, k, l)) break;
            if (strncmp(*argv+optoff, k+l, keylen-l)) continue;

            return keylen-l;
        }

        return nothing;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
callq 0x2090
leal -0x1(%rax), %r15d
movl 0x10(%rbx), %r12d
cmpl %r15d, %r12d
cmovbl %r12d, %r15d
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rsp)
movl %eax, %r13d
movq (%rcx), %rbp
addq %rbp, %r12
incq %r15
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x5a46
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x5a64
leaq (%r14,%rbx), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x20a0
testl %eax, %eax
je 0x5a6d
incq %rbx
decq %r13
cmpq %rbx, %r15
jne 0x5a2f
xorl %ecx, %ecx
movq 0x8(%rsp), %rax
jmp 0x5a7e
movq 0x10(%rsp), %rcx
subl %ebx, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, %cl
movb %cl, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/game.cc
// Function: main
int main()
{
	string resp;
	// distributions and engines have state,
    // they must be defined outside the loop!
	default_random_engine e;  

	// 50/50 odds by default
	bernoulli_distribution b(0.55); // give the house a slight edge

	do {
		bool first = b(e);    // if true, the program will go first
		cout << (first ? "We go first" 
	                   : "You get to go first") << endl;
		// play the game passing the indicator of who goes first
		cout << ((play(first)) ? "sorry, you lost" 
	                           : "congrats, you won") << endl;
		cout << "play again? Enter 'yes' or 'no'" << endl;
	} while (cin >> resp && resp[0] == 'y');

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x58(%rbp), %rbx
movq $0x1, (%rbx)
movq 0x2d76(%rip), %r14      # 0x3fd0
leaq 0xe31(%rip), %r15       # 0x2092
movq 0x2d78(%rip), %r12      # 0x3fe0
leaq -0x50(%rbp), %r13
movq %rbx, %rdi
callq 0x13d8
movsd %xmm0, -0x30(%rbp)
xorl %eax, %eax
movsd 0xd85(%rip), %xmm0      # 0x2008
ucomisd -0x30(%rbp), %xmm0
setbe %al
leaq 0xdca(%rip), %rsi       # 0x205c
leaq 0xdb7(%rip), %rcx       # 0x2050
cmovaq %rcx, %rsi
leaq 0xb(,%rax,8), %rdx
movq %r14, %rdi
callq 0x10a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
movsd 0xd2a(%rip), %xmm0      # 0x2008
ucomisd -0x30(%rbp), %xmm0
setbe %al
leaq 0xd93(%rip), %rsi       # 0x2080
leaq 0xd7c(%rip), %rcx       # 0x2070
cmovaq %rcx, %rsi
leaq 0xf(,%rax,2), %rdx
movq %r14, %rdi
callq 0x10a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movl $0x1f, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq %r12, %rdi
movq %r13, %rsi
callq 0x10b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq -0x50(%rbp), %rdi
jne 0x138c
cmpb $0x79, (%rdi)
je 0x126c
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x13a1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1090
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x13d0
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/arwn[P]baby-shark/babyshark.cpp
// Function: main
int
main(void)
{
  using namespace std::chrono_literals;
  Bullshit baby_shark_machine;
  char c;
  for (int i = 0; i < 100; i++) {
    baby_shark_machine.step();
  }
  return {};
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x240a
movl $0x64, %ebp
movq %rbx, %rdi
callq 0x2b9c
decl %ebp
jne 0x23c2
leaq 0x20(%rsp), %rdi
callq 0x33dc
leaq 0x8(%rsp), %rdi
callq 0x2cbe
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x33dc
leaq 0x8(%rsp), %rdi
callq 0x2cbe
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/arwn[P]baby-shark/babyshark.cpp
// Function: Bullshit::execute_state()
void execute_state()
  {
    std::cout << sharktable[state] << ' ' << std::flush;
    std::string command =
      "aplay audio/" + sharktable[state] + ".wav 2>/dev/null >/dev/null";
    system(command.c_str());
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movq 0x8(%rdi), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq 0x2d9e(%rip), %rdi      # 0x5fd8
callq 0x2150
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movl (%rbx), %edx
shlq $0x5, %rdx
addq 0x8(%rbx), %rdx
leaq 0xe4c(%rip), %rsi       # 0x40b9
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3353
leaq 0xe45(%rip), %rsi       # 0x40c6
movq %rbx, %rdi
callq 0x21d0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x32b0
movq %rdi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x32ba
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rcx
movq -0x10(%rcx), %rax
cmpq %rcx, %rax
je 0x32f5
movq 0x38(%rsp), %rsi
incq %rsi
movq %rax, %rdi
callq 0x2140
movq 0x8(%rsp), %rdi
callq 0x20f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3311
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x334b
movq 0x18(%rsp), %rsi
jmp 0x3343
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x334b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::cut_vertex_from(bool const* const*, Vertices&, int)
void Vertices::cut_vertex_from( const bool * const *conn, Vertices &v, int vertex_index ) {
	vertices.resize(0);
	for(vvec_type::const_iterator iter = v.vertices.begin(); iter != v.vertices.end(); ++iter) {
		if(conn[vertex_index][iter->get_index()])
			vertices.push_back(*iter);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
callq 0x2e06
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x266c
movslq %ebp, %r13
movq (%r14,%r13,8), %rax
movslq (%r12), %rcx
cmpb $0x1, (%rax,%rcx)
jne 0x2662
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x2657
movq (%r12), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r15)
jmp 0x2662
movq %r15, %rdi
movq %r12, %rdx
callq 0x3064
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x2631
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop