LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::FastWriter::write[abi:cxx11](Json::Value const&)
std::string 
FastWriter::write( const Value &root )
{
   document_ = "";
   writeValue( root );
   document_ += "\n";
   return document_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
leaq 0xa28e(%rip), %rsi      # 0x134c73
callq 0x869f0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12aa30
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
leaq 0x5de9(%rip), %rsi      # 0x1307f2
callq 0x866c0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x8, %rsi
callq 0x86350
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledWriter::write[abi:cxx11](Json::Value const&)
std::string 
StyledWriter::write( const Value &root )
{
   document_ = "";
   addChildValues_ = false;
   indentString_ = "";
   writeCommentBeforeValue( root );
   writeValue( root );
   writeCommentAfterValueOnSameLine( root );
   document_ += "\n";
   return document_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
leaq 0x9b7e(%rip), %rsi      # 0x134c73
callq 0x869f0
movq 0x8(%rsp), %rdi
movb $0x0, 0x68(%rdi)
addq $0x40, %rdi
leaq 0x9b65(%rip), %rsi      # 0x134c73
callq 0x869f0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12b180
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12b270
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12ba60
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x56a2(%rip), %rsi      # 0x1307f2
callq 0x866c0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x20, %rsi
callq 0x86350
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledWriter::writeCommentBeforeValue(Json::Value const&)
void 
StyledWriter::writeCommentBeforeValue( const Value &root )
{
   if ( !root.hasComment( commentBefore ) )
      return;
   document_ += normalizeEOL( root.getComment( commentBefore ) );
   document_ += "\n";
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x124870
testb $0x1, %al
jne 0x12b1aa
jmp 0x12b211
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
callq 0x1248b0
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x12c530
jmp 0x12b1d1
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x48(%rsp), %rsi
callq 0x86910
jmp 0x12b1e6
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x12b1f2
leaq 0x28(%rsp), %rdi
callq 0x86f68
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x55e6(%rip), %rsi      # 0x1307f2
callq 0x866c0
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x12b242
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x12b240
jmp 0x12b242
leaq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0x12b24e
jmp 0x12b250
movq 0x20(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void 
StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
{
   if ( root.hasComment( commentAfterOnSameLine ) )
      document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );

   if ( root.hasComment( commentAfter ) )
   {
      document_ += "\n";
      document_ += normalizeEOL( root.getComment( commentAfter ) );
      document_ += "\n";
   }
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc8(%rsp), %rdi
movl $0x1, %esi
callq 0x124870
testb $0x1, %al
jne 0x12ba9f
jmp 0x12bb90
movq 0xc8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %edx
callq 0x1248b0
movq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x12c530
jmp 0x12bacf
leaq 0x7b8d(%rip), %rsi      # 0x133663
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0xbafb0
jmp 0x12baed
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0xa8(%rsp), %rsi
callq 0x86910
jmp 0x12bb05
leaq 0xa8(%rsp), %rdi
callq 0x86f68
jmp 0x12bb14
leaq 0x88(%rsp), %rdi
callq 0x86f68
jmp 0x12bb23
leaq 0x68(%rsp), %rdi
callq 0x86f68
jmp 0x12bb90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x12bb7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x12bb6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x86f68
jmp 0x12bb6c
jmp 0x12bb6e
leaq 0x88(%rsp), %rdi
callq 0x86f68
jmp 0x12bb7d
jmp 0x12bb7f
leaq 0x68(%rsp), %rdi
callq 0x86f68
jmp 0x12bb8b
jmp 0x12bc6f
movq 0xc8(%rsp), %rdi
movl $0x2, %esi
callq 0x124870
testb $0x1, %al
jne 0x12bbab
jmp 0x12bc67
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x4c37(%rip), %rsi      # 0x1307f2
callq 0x866c0
movq 0xc8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x2, %edx
callq 0x1248b0
movq (%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x12c530
jmp 0x12bbeb
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x38(%rsp), %rsi
callq 0x86910
jmp 0x12bc00
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0x12bc0c
leaq 0x18(%rsp), %rdi
callq 0x86f68
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x4bcc(%rip), %rsi      # 0x1307f2
callq 0x866c0
jmp 0x12bc67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x12bc59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0x12bc57
jmp 0x12bc59
leaq 0x18(%rsp), %rdi
callq 0x86f68
jmp 0x12bc65
jmp 0x12bc6f
addq $0xd8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledWriter::writeIndent()
void 
StyledWriter::writeIndent()
{
   if ( !document_.empty() )
   {
      char last = document_[document_.length()-1];
      if ( last == ' ' )     // already indented
         return;
      if ( last != '\n' )    // Comments may add new-line
         document_ += '\n';
   }
   document_ += indentString_;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x20, %rdi
callq 0x86c90
testb $0x1, %al
jne 0x12c49c
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
callq 0x86ac0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x86f20
movb (%rax), %al
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
cmpl $0x20, %eax
jne 0x12c47d
jmp 0x12c4b1
movsbl 0x1f(%rsp), %eax
cmpl $0xa, %eax
je 0x12c49a
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x86480
jmp 0x12c49c
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
addq $0x20, %rdi
callq 0x86910
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledWriter::normalizeEOL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string 
StyledWriter::normalizeEOL( const std::string &text )
{
   std::string normalized;
   normalized.reserve( text.length() );
   const char *begin = text.c_str();
   const char *end = begin + text.length();
   const char *current = begin;
   while ( current != end )
   {
      char c = *current++;
      if ( c == '\r' ) // mac or dos EOL
      {
         if ( *current == '\n' ) // convert dos EOL
            ++current;
         normalized += '\n';
      }
      else // handle unix EOL & other char
         normalized += c;
   }
   return normalized;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x86a30
movq 0x68(%rsp), %rdi
callq 0x86ac0
movq %rax, 0x28(%rsp)
jmp 0x12c566
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x86b80
jmp 0x12c577
movq 0x68(%rsp), %rdi
callq 0x86320
movq %rax, 0x10(%rsp)
jmp 0x12c588
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
callq 0x86ac0
movq %rax, 0x8(%rsp)
jmp 0x12c5ac
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x12c65a
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rsp)
movb (%rax), %al
movb %al, 0x37(%rsp)
movsbl 0x37(%rsp), %eax
cmpl $0xd, %eax
jne 0x12c642
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x12c62f
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x12c62f
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x86f68
jmp 0x12c67a
movq 0x18(%rsp), %rdi
movl $0xa, %esi
callq 0x86480
jmp 0x12c640
jmp 0x12c655
movq 0x18(%rsp), %rdi
movsbl 0x37(%rsp), %esi
callq 0x86480
jmp 0x12c653
jmp 0x12c655
jmp 0x12c5c7
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x12c670
movq 0x18(%rsp), %rdi
callq 0x86f68
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
jmp 0x12c67c
movq 0x58(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledStreamWriter::write(std::ostream&, Json::Value const&)
void
StyledStreamWriter::write( std::ostream &out, const Value &root )
{
   document_ = &out;
   addChildValues_ = false;
   indentString_ = "";
   writeCommentBeforeValue( root );
   writeValue( root );
   writeCommentAfterValueOnSameLine( root );
   *document_ << "\n";
   document_ = NULL; // Forget the stream, for safety.
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rdi)
movb $0x0, 0x68(%rdi)
addq $0x20, %rdi
leaq 0x84ee(%rip), %rsi      # 0x134c73
callq 0x869f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x12c7e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x12c8d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x12d0c0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x402b(%rip), %rsi      # 0x1307f2
callq 0x86700
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
void 
StyledStreamWriter::writeCommentBeforeValue( const Value &root )
{
   if ( !root.hasComment( commentBefore ) )
      return;
   *document_ << normalizeEOL( root.getComment( commentBefore ) );
   *document_ << "\n";
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x124870
testb $0x1, %al
jne 0x12c80a
jmp 0x12c879
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
callq 0x1248b0
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x12dab0
jmp 0x12c83e
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x86640
jmp 0x12c84e
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x12c85a
leaq 0x28(%rsp), %rdi
callq 0x86f68
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x3f7e(%rip), %rsi      # 0x1307f2
callq 0x86700
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x12c8aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x12c8a8
jmp 0x12c8aa
leaq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0x12c8b6
jmp 0x12c8b8
movq 0x20(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::StyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void 
StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )
{
   if ( root.hasComment( commentAfterOnSameLine ) )
      *document_ << " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );

   if ( root.hasComment( commentAfter ) )
   {
      *document_ << "\n";
      *document_ << normalizeEOL( root.getComment( commentAfter ) );
      *document_ << "\n";
   }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
callq 0x124870
testb $0x1, %al
jne 0x12d0ff
jmp 0x12d1fa
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xd8(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %edx
callq 0x1248b0
movq 0x18(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x12dab0
jmp 0x12d13d
leaq 0x651f(%rip), %rsi      # 0x133663
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0xbafb0
jmp 0x12d15b
movq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x86640
jmp 0x12d16f
leaq 0xb8(%rsp), %rdi
callq 0x86f68
jmp 0x12d17e
leaq 0x98(%rsp), %rdi
callq 0x86f68
jmp 0x12d18d
leaq 0x78(%rsp), %rdi
callq 0x86f68
jmp 0x12d1fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x12d1e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x12d1d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x86f68
jmp 0x12d1d6
jmp 0x12d1d8
leaq 0x98(%rsp), %rdi
callq 0x86f68
jmp 0x12d1e7
jmp 0x12d1e9
leaq 0x78(%rsp), %rdi
callq 0x86f68
jmp 0x12d1f5
jmp 0x12d2e3
movq 0xd8(%rsp), %rdi
movl $0x2, %esi
callq 0x124870
testb $0x1, %al
jne 0x12d215
jmp 0x12d2db
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x35cd(%rip), %rsi      # 0x1307f2
callq 0x86700
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0xd8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x2, %edx
callq 0x1248b0
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x12dab0
jmp 0x12d264
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x86640
jmp 0x12d274
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x12d280
leaq 0x28(%rsp), %rdi
callq 0x86f68
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x3558(%rip), %rsi      # 0x1307f2
callq 0x86700
jmp 0x12d2db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x12d2cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x12d2cb
jmp 0x12d2cd
leaq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0x12d2d9
jmp 0x12d2e3
addq $0xe8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: test_default_constructor(int)
void test_default_constructor(int line) {
  where(line, __func__);
  helper::mark_call_stack();
  const delayed_init<const helper> d;
  helper::check_call_stack({});
  assert(!d);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %edi
leaq 0x7c4b(%rip), %rsi      # 0x900e
callq 0x1350
callq 0x3350
leaq 0x2c(%rsp), %rdi
callq 0x3370
leaq 0x18(%rsp), %rdi
callq 0x3470
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3380
jmp 0x13f2
leaq 0x2c(%rsp), %rdi
callq 0x3490
xorb $-0x1, %al
testb $0x1, %al
jne 0x1404
jmp 0x1406
jmp 0x143f
leaq 0x7c1a(%rip), %rdi      # 0x9027
leaq 0x7c16(%rip), %rsi      # 0x902a
movl $0xad, %edx
leaq 0x7c1b(%rip), %rcx      # 0x903b
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x34a0
jmp 0x144e
leaq 0x2c(%rsp), %rdi
callq 0x34a0
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: test_conversion_to_bool(int, overload::delayed_init<helper const> const&, bool)
void test_conversion_to_bool(int line, const delayed_init<const helper>& d,
  bool is_init) {
  where(line, __func__);
  helper::mark_call_stack();
  assert(static_cast<bool>(d) == is_init);
  helper::check_call_stack({});
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl 0x24(%rsp), %edi
leaq 0x7bde(%rip), %rsi      # 0x905e
callq 0x1350
callq 0x3350
movq 0x18(%rsp), %rdi
callq 0x3490
andb $0x1, %al
movzbl %al, %eax
movb 0x17(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x14a9
jmp 0x14c8
leaq 0x7bc6(%rip), %rdi      # 0x9076
leaq 0x7b73(%rip), %rsi      # 0x902a
movl $0x122, %edx            # imm = 0x122
leaq 0x7bd3(%rip), %rcx      # 0x9096
callq 0x1090
movq %rsp, %rdi
callq 0x3470
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3380
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: test_init_initialised(int)
void test_init_initialised(int line) {
  where(line, __func__);
  delayed_init<const helper> d(helper(1));
  helper::mark_call_stack();
  try {
    d.init(1);
    assert(false);
  }
  catch(std::logic_error&) {
  }
  catch (...) {
    assert(false);
  }
  helper::check_call_stack({});
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl 0x44(%rsp), %edi
leaq 0x7bdf(%rip), %rsi      # 0x90e2
callq 0x1350
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x34b0
movq 0x8(%rsp), %rsi
leaq 0x3c(%rsp), %rdi
callq 0x34f0
movq 0x8(%rsp), %rdi
callq 0x3520
callq 0x3350
jmp 0x153c
movl $0x1, 0x28(%rsp)
leaq 0x3c(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3560
jmp 0x1555
leaq 0x7b9c(%rip), %rdi      # 0x90f8
leaq 0x7ac7(%rip), %rsi      # 0x902a
movl $0x13f, %edx            # imm = 0x13F
leaq 0x7b8f(%rip), %rcx      # 0x90fe
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x34a0
jmp 0x1617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x15ee
movq 0x30(%rsp), %rdi
callq 0x1050
movq %rax, 0x20(%rsp)
callq 0x1150
jmp 0x15c2
jmp 0x15c4
leaq 0x10(%rsp), %rdi
callq 0x3470
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3380
jmp 0x15df
leaq 0x3c(%rsp), %rdi
callq 0x34a0
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1050
leaq 0x7af9(%rip), %rdi      # 0x90f8
leaq 0x7a24(%rip), %rsi      # 0x902a
movl $0x144, %edx            # imm = 0x144
leaq 0x7aec(%rip), %rcx      # 0x90fe
callq 0x1090
movq 0x30(%rsp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: helper::check_call_stack(std::initializer_list<helper::method>)
static void check_call_stack(std::initializer_list<method> methods) {
    for (auto f : methods) {
      assert(call_stack.top() == f);
      call_stack.pop();
    }
    assert(call_stack.top() == none);
    call_stack.pop();
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x6270
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x6280
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x341e
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0xad24(%rip), %rdi      # 0xe0f8
callq 0x62c0
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x33e3
jmp 0x3402
leaq 0x5d46(%rip), %rdi      # 0x9130
leaq 0x5c39(%rip), %rsi      # 0x902a
movl $0x46, %edx
leaq 0x5d49(%rip), %rcx      # 0x9146
callq 0x1090
leaq 0xacef(%rip), %rdi      # 0xe0f8
callq 0x62d0
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0x33b6
leaq 0xacd3(%rip), %rdi      # 0xe0f8
callq 0x62c0
cmpl $0x0, (%rax)
jne 0x3431
jmp 0x3450
leaq 0x5d52(%rip), %rdi      # 0x918a
leaq 0x5beb(%rip), %rsi      # 0x902a
movl $0x49, %edx
leaq 0x5cfb(%rip), %rcx      # 0x9146
callq 0x1090
leaq 0xaca1(%rip), %rdi      # 0xe0f8
callq 0x62d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_constructor<helper, helper&>(int, helper&, bool, std::initializer_list<helper::method>)
void test_constructor(int line, U&& src, bool is_init, method_list ml) {
  where(line, __func__);
  helper::mark_call_stack();
  const delayed_init<T> d(std::forward<U>(src));
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d) == is_init);
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movl 0x44(%rsp), %edi
leaq 0x5b9d(%rip), %rsi      # 0x91f7
callq 0x1350
callq 0x3350
movq 0x38(%rsp), %rsi
leaq 0x2c(%rsp), %rdi
callq 0x5c70
movups 0x48(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3380
jmp 0x368e
leaq 0x2c(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movzbl %al, %eax
movb 0x37(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x36ad
jmp 0x36e6
leaq 0x59c2(%rip), %rdi      # 0x9076
leaq 0x596f(%rip), %rsi      # 0x902a
movl $0xba, %edx
leaq 0x5b41(%rip), %rcx      # 0x9208
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x5c60
jmp 0x36f5
leaq 0x2c(%rsp), %rdi
callq 0x5c60
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x1180
nop
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_destructor<overload::delayed_init<helper>>(int, overload::delayed_init<helper> const&, std::initializer_list<helper::method>)
void test_destructor(int line, const U& src, method_list ml) {
  where(line, __func__);
  {
    const delayed_init<const helper> d(src);
    helper::mark_call_stack();
  }
  helper::check_call_stack(ml);
}

// Assembly:
subq $0x48, %rsp
movq %rdx, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl 0x34(%rsp), %edi
leaq 0x5476(%rip), %rsi      # 0x9808
callq 0x1350
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x5600
callq 0x3350
jmp 0x43ad
leaq 0x20(%rsp), %rdi
callq 0x34a0
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3380
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x34a0
movq 0x18(%rsp), %rdi
callq 0x1180
nop
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_assignment<overload::delayed_init<helper>, helper&>(int, helper&, overload::delayed_init<helper> const&, bool, std::initializer_list<helper::method>)
void test_assignment(int line, U&& from, const T& to, bool is_init,
  method_list ml) {
  
  where(line, __func__);
  delayed_init<helper> d(to);
  helper::mark_call_stack();
  d = std::forward<U>(from);
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d) == is_init);
}

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movq %r8, 0x48(%rsp)
movq %r9, 0x50(%rsp)
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movl 0x44(%rsp), %edi
leaq 0x53e9(%rip), %rsi      # 0x9818
callq 0x1350
movq 0x30(%rsp), %rsi
leaq 0x24(%rsp), %rdi
callq 0x77c0
callq 0x3350
jmp 0x444a
movq 0x38(%rsp), %rsi
leaq 0x24(%rsp), %rdi
callq 0x7cd0
movups 0x48(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3380
jmp 0x4472
leaq 0x24(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movzbl %al, %eax
movb 0x2f(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4491
jmp 0x44ca
leaq 0x4bde(%rip), %rdi      # 0x9076
leaq 0x4b8b(%rip), %rsi      # 0x902a
movl $0xd8, %edx
leaq 0x537d(%rip), %rcx      # 0x9828
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x24(%rsp), %rdi
callq 0x5c60
jmp 0x44d9
leaq 0x24(%rsp), %rdi
callq 0x5c60
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_indirection_uninitialised<overload::delayed_init<helper>>(int)
void test_indirection_uninitialised(int line) {

  where(line, __func__);
  D d;
  helper::mark_call_stack();
  try {
    (*d).get();
    assert(false);
  }
  catch (std::logic_error&) {
  }
  catch (...) {
    assert(false);
  }
  helper::check_call_stack({});
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl 0x44(%rsp), %edi
leaq 0x508d(%rip), %rsi      # 0x9c20
callq 0x1350
leaq 0x3c(%rsp), %rdi
callq 0x3cb0
callq 0x3350
jmp 0x4ba9
leaq 0x3c(%rsp), %rdi
callq 0x8230
movq %rax, 0x8(%rsp)
jmp 0x4bba
movq 0x8(%rsp), %rdi
callq 0x82b0
leaq 0x452d(%rip), %rdi      # 0x90f8
leaq 0x4458(%rip), %rsi      # 0x902a
movl $0xe7, %edx
leaq 0x5061(%rip), %rcx      # 0x9c3f
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x5c60
jmp 0x4c86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4c5d
movq 0x30(%rsp), %rdi
callq 0x1050
movq %rax, 0x20(%rsp)
callq 0x1150
jmp 0x4c31
jmp 0x4c33
leaq 0x10(%rsp), %rdi
callq 0x3470
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3380
jmp 0x4c4e
leaq 0x3c(%rsp), %rdi
callq 0x5c60
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1050
leaq 0x448a(%rip), %rdi      # 0x90f8
leaq 0x43b5(%rip), %rsi      # 0x902a
movl $0xec, %edx
leaq 0x4fbe(%rip), %rcx      # 0x9c3f
callq 0x1090
movq 0x30(%rsp), %rdi
callq 0x1180
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_indirection_initialised<overload::delayed_init<helper>>(int, std::initializer_list<helper::method>)
void test_indirection_initialised(int line, method_list ml) {
  where(line, __func__);
  D d(helper(1));
  helper::mark_call_stack();
  (*d).get();
  helper::check_call_stack(ml);
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl %edi, 0x44(%rsp)
movl 0x44(%rsp), %edi
leaq 0x4f48(%rip), %rsi      # 0x9d05
callq 0x1350
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x34b0
movq 0x8(%rsp), %rsi
leaq 0x3c(%rsp), %rdi
callq 0x3cc0
movq 0x8(%rsp), %rdi
callq 0x3520
callq 0x3350
jmp 0x4df6
leaq 0x3c(%rsp), %rdi
callq 0x8230
movq %rax, (%rsp)
jmp 0x4e06
movq (%rsp), %rdi
callq 0x82b0
movups 0x48(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3380
jmp 0x4e2a
leaq 0x3c(%rsp), %rdi
callq 0x5c60
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x5c60
movq 0x30(%rsp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_getter<overload::delayed_init<helper>>(int, overload::delayed_init<helper> const&, bool, bool)
void test_getter(int line, const delayed_init<helper>& src, bool is_const,
  bool is_init) {
  
  where(line, __func__);
  D d(src);
  const auto p = d.get();
  assert(is_pointer_to_const(p) == is_const);
  assert(static_cast<bool>(p) == is_init);
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movb %dl, %cl
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %cl
movb %cl, 0x37(%rsp)
andb $0x1, %al
movb %al, 0x36(%rsp)
movl 0x44(%rsp), %edi
leaq 0x4dd9(%rip), %rsi      # 0x9d22
callq 0x1350
movq 0x38(%rsp), %rsi
leaq 0x2c(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x77c0
movq 0x8(%rsp), %rdi
callq 0x7a70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x83b0
movb %al, 0x13(%rsp)
jmp 0x4f81
movb 0x13(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x37(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4f9a
jmp 0x4fd3
leaq 0x4d8d(%rip), %rdi      # 0x9d2e
leaq 0x4082(%rip), %rsi      # 0x902a
movl $0x109, %edx            # imm = 0x109
leaq 0x4d9d(%rip), %rcx      # 0x9d51
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x5c60
jmp 0x501f
cmpq $0x0, 0x20(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb 0x36(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4ff1
jmp 0x5010
leaq 0x4dbe(%rip), %rdi      # 0x9db6
leaq 0x402b(%rip), %rsi      # 0x902a
movl $0x10a, %edx            # imm = 0x10A
leaq 0x4d46(%rip), %rcx      # 0x9d51
callq 0x1090
leaq 0x2c(%rsp), %rdi
callq 0x5c60
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1180
nopl (%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_dereference<overload::delayed_init<helper>>(int, std::initializer_list<helper::method>)
void test_dereference(int line, method_list ml) {
  where(line, __func__);
  D d(helper(1));
  helper::mark_call_stack();
  d->get();
  helper::check_call_stack(ml);
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl %edi, 0x44(%rsp)
movl 0x44(%rsp), %edi
leaq 0x4c00(%rip), %rsi      # 0x9f1d
callq 0x1350
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x34b0
movq 0x8(%rsp), %rsi
leaq 0x3c(%rsp), %rdi
callq 0x3cc0
movq 0x8(%rsp), %rdi
callq 0x3520
callq 0x3350
jmp 0x5356
leaq 0x3c(%rsp), %rdi
callq 0x83d0
movq %rax, %rdi
callq 0x82b0
movups 0x48(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3380
jmp 0x5383
leaq 0x3c(%rsp), %rdi
callq 0x5c60
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x5c60
movq 0x30(%rsp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
nop
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_init_uninitialised<int>(int, std::initializer_list<helper::method>, int&&)
void test_init_uninitialised(int line, method_list ml, Args&&... args) {
  where(line, __func__);
  delayed_init<const helper> d;
  helper::mark_call_stack();
  d.init(std::forward<Args>(args)...);
  helper::check_call_stack(ml);
  assert(d);
  assert(d.get());
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movl %edi, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x34(%rsp), %edi
leaq 0x48bc(%rip), %rsi      # 0x9f2e
callq 0x1350
leaq 0x20(%rsp), %rdi
callq 0x3370
callq 0x3350
jmp 0x5688
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3560
jmp 0x5699
movups 0x38(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3380
jmp 0x56b2
leaq 0x20(%rsp), %rdi
callq 0x3490
testb $0x1, %al
jne 0x56c2
jmp 0x56c4
jmp 0x56fd
leaq 0x395d(%rip), %rdi      # 0x9028
leaq 0x3958(%rip), %rsi      # 0x902a
movl $0x131, %edx            # imm = 0x131
leaq 0x4868(%rip), %rcx      # 0x9f46
callq 0x1090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x34a0
jmp 0x573d
leaq 0x20(%rsp), %rdi
callq 0x7bf0
cmpq $0x0, %rax
je 0x570f
jmp 0x572e
leaq 0x487a(%rip), %rdi      # 0x9f90
leaq 0x390d(%rip), %rsi      # 0x902a
movl $0x132, %edx            # imm = 0x132
leaq 0x481d(%rip), %rcx      # 0x9f46
callq 0x1090
leaq 0x20(%rsp), %rdi
callq 0x34a0
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1180
nopw (%rax,%rax)
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_swap_member<overload::delayed_init<helper>, overload::delayed_init<helper>>(int, overload::delayed_init<helper>&, overload::delayed_init<helper>&, std::initializer_list<helper::method>)
void test_swap_member(int line, D1& d1, D2& d2, method_list ml) {
  where(line, __func__);
  const bool is_init1 = static_cast<bool>(d1);
  const bool is_init2 = static_cast<bool>(d2);
  helper::mark_call_stack();
  d1.swap(d2);
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d2) == is_init1);
  assert(static_cast<bool>(d1) == is_init2);
}

// Assembly:
subq $0x48, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x34(%rsp), %edi
leaq 0x4565(%rip), %rsi      # 0xa0dc
callq 0x1350
movq 0x28(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movb %al, 0x1e(%rsp)
callq 0x3350
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x8650
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3380
movq 0x20(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movzbl %al, %eax
movb 0x1f(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5bf2
jmp 0x5c11
leaq 0x44f4(%rip), %rdi      # 0xa0ed
leaq 0x342a(%rip), %rsi      # 0x902a
movl $0x155, %edx            # imm = 0x155
leaq 0x4503(%rip), %rcx      # 0xa10f
callq 0x1090
movq 0x28(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movzbl %al, %eax
movb 0x1e(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5c30
jmp 0x5c4f
leaq 0x4557(%rip), %rdi      # 0xa18e
leaq 0x33ec(%rip), %rsi      # 0x902a
movl $0x156, %edx            # imm = 0x156
leaq 0x44c5(%rip), %rcx      # 0xa10f
callq 0x1090
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_swap_non_member<overload::delayed_init<helper>, overload::delayed_init<helper>>(int, overload::delayed_init<helper>&, overload::delayed_init<helper>&, std::initializer_list<helper::method>)
void test_swap_non_member(int line, D1& d1, D2& d2, method_list ml) {
  where(line, __func__);
  const bool is_init1 = static_cast<bool>(d1);
  const bool is_init2 = static_cast<bool>(d2);
  helper::mark_call_stack();
  swap(d1, d2);
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d2) == is_init1);
  assert(static_cast<bool>(d1) == is_init2);
}

// Assembly:
subq $0x48, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x34(%rsp), %edi
leaq 0x44e9(%rip), %rsi      # 0xa1b0
callq 0x1350
movq 0x28(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movb %al, 0x1e(%rsp)
callq 0x3350
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x86e0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3380
movq 0x20(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movzbl %al, %eax
movb 0x1f(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5d42
jmp 0x5d61
leaq 0x43a4(%rip), %rdi      # 0xa0ed
leaq 0x32da(%rip), %rsi      # 0x902a
movl $0x165, %edx            # imm = 0x165
leaq 0x4469(%rip), %rcx      # 0xa1c5
callq 0x1090
movq 0x28(%rsp), %rdi
callq 0x74b0
andb $0x1, %al
movzbl %al, %eax
movb 0x1e(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5d80
jmp 0x5d9f
leaq 0x4407(%rip), %rdi      # 0xa18e
leaq 0x329c(%rip), %rsi      # 0x902a
movl $0x166, %edx            # imm = 0x166
leaq 0x442b(%rip), %rcx      # 0xa1c5
callq 0x1090
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: cassioneri[P]delayed_init/./delayed_init.h
// Function: void overload::delayed_init<helper>::assign<helper&>(bool, helper&)
void assign(bool src_is_init, U&& src_obj) {
    if (!is_init_)
      init_me(src_is_init, std::forward<U>(src_obj));
    else if (src_is_init)
      obj_ = std::forward<U>(src_obj);
    else
      destroy();
  }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
jne 0x7d50
movq 0x8(%rsp), %rdi
movb 0x1f(%rsp), %al
movq 0x10(%rsp), %rdx
andb $0x1, %al
movzbl %al, %esi
callq 0x7d80
jmp 0x7d78
testb $0x1, 0x1f(%rsp)
je 0x7d6c
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x4, %rdi
callq 0x7dc0
jmp 0x7d76
movq 0x8(%rsp), %rdi
callq 0x7740
jmp 0x7d78
addq $0x28, %rsp
retq
nopl (%rax)
// File: cassioneri[P]delayed_init/./delayed_init.h
// Function: overload::delayed_init<helper>::swap(overload::delayed_init<helper>&)
void swap(delayed_init& src)
    noexcept(
      std::is_nothrow_copy_constructible<T>::value &&
      std::is_nothrow_move_constructible<T>::value &&
      traits::is_nothrow_swappable<T>::value
    ) {
    if (is_init_) {
      if (src.is_init_) {
        
        using std::swap;
        swap(obj_, src.obj_);
      }
      else {
        src.init_obj(std::move(obj_));
        destroy();
      }
    }
    else if (src.is_init_) {
      init_obj(std::move(src.obj_));
      src.destroy();
    }
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, (%rax)
je 0x86ab
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0x868e
movq (%rsp), %rdi
addq $0x4, %rdi
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
callq 0x1300
jmp 0x86a9
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x4, %rsi
callq 0x7780
movq (%rsp), %rdi
callq 0x7740
jmp 0x86d3
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0x86d1
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
callq 0x7780
movq 0x8(%rsp), %rdi
callq 0x7740
jmp 0x86d3
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Gydo194[P]server/server/Server.cpp
// Function: Server::setup(int)
void Server::setup(int port)
{
    mastersocket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (mastersocket_fd < 0) {
        perror("Socket creation failed");
    }

    FD_ZERO(&masterfds);
    FD_ZERO(&tempfds);

    memset(&servaddr, 0, sizeof (servaddr)); //bzero
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htons(INADDR_ANY);
    servaddr.sin_port = htons(port);

    bzero(input_buffer,INPUT_BUFFER_SIZE); //zero the input buffer before use to avoid random data appearing in first receives
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x20b0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10c(%rax)
cmpl $0x0, 0x10c(%rax)
jge 0x2779
leaq 0x3890(%rip), %rdi      # 0x6004
callq 0x21f0
jmp 0x277b
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0x10, %rax
jae 0x27b1
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x278e
jmp 0x27b3
jmp 0x27b5
movq -0x30(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x10, %rax
jae 0x27ed
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27ca
jmp 0x27ef
movq -0x30(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
movq -0x30(%rbp), %rax
movw $0x2, 0x198(%rax)
xorl %edi, %edi
callq 0x2060
movw %ax, %cx
movq -0x30(%rbp), %rax
movzwl %cx, %ecx
movl %ecx, 0x19c(%rax)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x2060
movq -0x30(%rbp), %rdi
movw %ax, 0x19a(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
xorl %esi, %esi
movl $0x64, %edx
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Gydo194[P]server/server/Server.cpp
// Function: Server::initializeSocket()
void Server::initializeSocket()
{
	#ifdef SERVER_DEBUG
	std::cout << "[SERVER] initializing socket\n";
	#endif
	int opt_value = 1;
	int ret_test = setsockopt(mastersocket_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &opt_value, sizeof (int));
	#ifdef SERVER_DEBUG
	printf("[SERVER] setsockopt() ret %d\n", ret_test);
    	#endif
	if (ret_test < 0) {
        	perror("[SERVER] [ERROR] setsockopt() failed");
		shutdown();
    	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl 0x10c(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x2978
leaq 0x36b1(%rip), %rdi      # 0x601b
callq 0x21f0
movq -0x18(%rbp), %rdi
callq 0x2980
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Gydo194[P]server/server/Server.cpp
// Function: Server::bindSocket()
void Server::bindSocket()
{
	#ifdef SERVER_DEBUG
	std::cout << "[SERVER] binding...\n";
	#endif
	int bind_ret = bind(mastersocket_fd, (struct sockaddr*) &servaddr, sizeof (servaddr));
	#ifdef SERVER_DEBUG
	printf("[SERVER] bind() ret %d\n", bind_ret);
	#endif
	if (bind_ret < 0) {
		perror("[SERVER] [ERROR] bind() failed");
	}
	FD_SET(mastersocket_fd, &masterfds); //insert the master socket file-descriptor into the master fd-set
	maxfd = mastersocket_fd; //set the current known maximum file descriptor count
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl 0x10c(%rsi), %edi
addq $0x198, %rsi            # imm = 0x198
movl $0x10, %edx
callq 0x2070
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x29f0
leaq 0x3655(%rip), %rdi      # 0x6040
callq 0x21f0
movq -0x18(%rbp), %rax
movl 0x10c(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, -0x20(%rbp)
movl 0x10c(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rdx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
orq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movl 0x10c(%rax), %ecx
movw %cx, 0x108(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Gydo194[P]server/server/Server.cpp
// Function: Server::handleNewConnection()
void Server::handleNewConnection()
{
	#ifdef SERVER_DEBUG
  	 std::cout << "[SERVER] [CONNECTION] handling new connection\n";
    	#endif
    	socklen_t addrlen = sizeof (client_addr);
    	tempsocket_fd = accept(mastersocket_fd, (struct sockaddr*) &client_addr, &addrlen);
    	
	if (tempsocket_fd < 0) {
        	perror("[SERVER] [ERROR] accept() failed");
	} else {
        	FD_SET(tempsocket_fd, &masterfds);
		//increment the maximum known file descriptor (select() needs it)
        	if (tempsocket_fd > maxfd) {
            		maxfd = tempsocket_fd;
			#ifdef SERVER_DEBUG
            		std::cout << "[SERVER] incrementing maxfd to " << maxfd << std::endl;
			#endif
        	}
        	#ifdef SERVER_DEBUG
        	printf("[SERVER] [CONNECTION] New connection on socket fd '%d'.\n",tempsocket_fd);
		#endif
    }
    newConnectionCallback(tempsocket_fd); //call the callback
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl $0x80, -0xc(%rbp)
movl 0x10c(%rsi), %edi
addq $0x118, %rsi            # imm = 0x118
leaq -0xc(%rbp), %rdx
callq 0x20d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x110(%rax)
cmpl $0x0, 0x110(%rax)
jge 0x2ae4
leaq 0x35a3(%rip), %rdi      # 0x6080
callq 0x21f0
jmp 0x2b4c
movq -0x18(%rbp), %rax
movl 0x110(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x18(%rbp), %rcx
movq %rax, -0x20(%rbp)
movl 0x110(%rcx), %eax
movl $0x40, %esi
cltd
idivl %esi
movq -0x20(%rbp), %rdx
cltq
orq 0x8(%rcx,%rax,8), %rdx
movq %rdx, 0x8(%rcx,%rax,8)
movl 0x110(%rcx), %eax
movzwl 0x108(%rcx), %ecx
cmpl %ecx, %eax
jle 0x2b4a
movq -0x18(%rbp), %rax
movl 0x110(%rax), %ecx
movw %cx, 0x108(%rax)
jmp 0x2b4c
movq -0x18(%rbp), %rcx
movq 0x240(%rcx), %rax
movl 0x110(%rcx), %ecx
movzwl %cx, %edi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Gydo194[P]server/server/Server.cpp
// Function: Server::recvInputFromExisting(int)
void Server::recvInputFromExisting(int fd)
{
    int nbytesrecv = recv(fd, input_buffer, INPUT_BUFFER_SIZE, 0);
    if (nbytesrecv <= 0)
    {
        //problem
        if (0 == nbytesrecv)
	{
        	disconnectCallback((uint16_t)fd);
		close(fd); //well then, bye bye.
        	FD_CLR(fd, &masterfds);
        	return;
        } else 
	{
        	perror("[SERVER] [ERROR] recv() failed");
        }
        close(fd); //close connection to client
        FD_CLR(fd, &masterfds); //clear the client fd from fd set
        return;
    }
    #ifdef SERVER_DEBUG
    printf("[SERVER] [RECV] Received '%s' from client!\n", input_buffer);
    #endif
    receiveCallback(fd,input_buffer);
    //memset(&input_buffer, 0, INPUT_BUFFER_SIZE); //zero buffer //bzero
    bzero(&input_buffer,INPUT_BUFFER_SIZE); //clear input buffer
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edi
addq $0x1a8, %rsi            # imm = 0x1A8
movl $0x64, %edx
xorl %ecx, %ecx
callq 0x20e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jg 0x2c69
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jne 0x2c12
movq -0x18(%rbp), %rax
movq 0x250(%rax), %rax
movl -0xc(%rbp), %ecx
movzwl %cx, %edi
callq *%rax
movl -0xc(%rbp), %edi
callq 0x2400
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rdx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
andq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x2c9a
leaq 0x3488(%rip), %rdi      # 0x60a1
callq 0x21f0
movl -0xc(%rbp), %edi
callq 0x2400
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rdx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
andq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x2c9a
movq -0x18(%rbp), %rsi
movq 0x248(%rsi), %rax
movl -0xc(%rbp), %ecx
addq $0x1a8, %rsi            # imm = 0x1A8
movzwl %cx, %edi
callq *%rax
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
xorl %esi, %esi
movl $0x64, %edx
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
// File: Gydo194[P]server/server/Server.cpp
// Function: Server::loop()
void Server::loop()
{
    tempfds = masterfds; //copy fd_set for select()
    #ifdef SERVER_DEBUG
    printf("[SERVER] [MISC] max fd = '%hu' \n", maxfd);
    std::cout << "[SERVER] [MISC] calling select()\n";
    #endif
    int sel = select(maxfd + 1, &tempfds, NULL, NULL, NULL); //blocks until activity
    //printf("[SERVER] [MISC] select() ret %d, processing...\n", sel);
    if (sel < 0) {
        perror("[SERVER] [ERROR] select() failed");
        shutdown();
    }

    //no problems, we're all set

    //loop the fd_set and check which socket has interactions available
    for (int i = 0; i <= maxfd; i++) {
        if (FD_ISSET(i, &tempfds)) { //if the socket has activity pending
            if (mastersocket_fd == i) {
                //new connection on master socket
                handleNewConnection();
            } else {
                //exisiting connection has new data
                recvInputFromExisting(i);
            }
        } //loop on to see if there is more
    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq %rdi, %rsi
addq $0x8, %rsi
addq $0x88, %rdi
movl $0x80, %edx
callq 0x21e0
movq -0x18(%rbp), %rsi
movzwl 0x108(%rsi), %edi
addl $0x1, %edi
addq $0x88, %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x2230
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x2d0f
leaq 0x33bf(%rip), %rdi      # 0x60c0
callq 0x21f0
movq -0x18(%rbp), %rdi
callq 0x2980
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movzwl 0x108(%rcx), %ecx
cmpl %ecx, %eax
jg 0x2da5
movl -0x10(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
movq 0x88(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x2d95
movq -0x18(%rbp), %rax
movl 0x10c(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x2d87
movq -0x18(%rbp), %rdi
callq 0x2a90
jmp 0x2d93
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x2b70
jmp 0x2d95
jmp 0x2d97
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2d16
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)