LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: princelab[P]emass/parser.cpp
// Function: Parser::parse_formula(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
void Parser::parse_formula(const wstring & frml)
{
  _tokenizer.set_input(frml);
  _tokenizer.get_token();
  Parser::ElementListNode * tmp = parse();
  
  if(_tokenizer._ttype != EOS) {
    delete tmp; 
    _tokenizer.error(L"End of input expected");
  }
  delete tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xc720
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0xc770
movq -0x58(%rbp), %rdi
callq 0xcb90
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x2, 0x8(%rax)
je 0xc6eb
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xc66b
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4150
movq -0x68(%rbp), %rdx
leaq 0x5b39(%rip), %rsi      # 0x121c8
leaq -0x38(%rbp), %rdi
callq 0xd6c0
jmp 0xc69a
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd030
jmp 0xc6a9
leaq -0x38(%rbp), %rdi
callq 0x4738
leaq -0x39(%rbp), %rdi
callq 0x4640
jmp 0xc6eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xc6e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4738
leaq -0x39(%rbp), %rdi
callq 0x4640
jmp 0xc70c
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0xc703
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: princelab[P]emass/parser.cpp
// Function: Parser::Tokenizer::error(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>)
void Parser::Tokenizer::error(wstring msg)
{
  msg += L":\n";
  _input.resize(_input.length() - ENDTOKEN.length());
  msg += _input + L"\n";
  msg += wstring(_last, L' ') + L"^\n";
  throw Parser::Error(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xe0(%rbp)
movq %rdi, %rax
movq -0xe0(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq 0x5287(%rip), %rsi      # 0x122f4
callq 0x40d0
movq -0xd8(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xc8(%rbp)
callq 0x45b0
movq %rax, -0xd0(%rbp)
leaq 0xe3e9(%rip), %rdi      # 0x1b480
callq 0x45b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
subq %rax, %rsi
callq 0x46b0
movq -0xc8(%rbp), %rsi
leaq 0x5238(%rip), %rdx      # 0x122f8
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xda50
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x4570
jmp 0xd0e5
leaq -0x30(%rbp), %rdi
callq 0x4738
movq -0xd8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x4150
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rcx
leaq -0x80(%rbp), %rdi
movl $0x20, %edx
callq 0xdad0
jmp 0xd131
leaq 0x51c8(%rip), %rdx      # 0x12300
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xd8a0
jmp 0xd147
movq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4570
jmp 0xd159
leaq -0x60(%rbp), %rdi
callq 0x4738
leaq -0x80(%rbp), %rdi
callq 0x4738
leaq -0x81(%rbp), %rdi
callq 0x4640
movb $0x1, -0xa9(%rbp)
movl $0x20, %edi
callq 0x4180
movq -0xc0(%rbp), %rsi
movq %rax, -0xf8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4340
jmp 0xd1a4
movq -0xf8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xdb40
jmp 0xd1b9
movq -0xf8(%rbp), %rdi
movb $0x0, -0xa9(%rbp)
leaq 0xdaf2(%rip), %rsi      # 0x1acc0
leaq -0x64f5(%rip), %rdx     # 0x6ce0
callq 0x45e0
jmp 0xd289
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4738
jmp 0xd280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd233
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd22a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4738
leaq -0x80(%rbp), %rdi
callq 0x4738
leaq -0x81(%rbp), %rdi
callq 0x4640
jmp 0xd280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd267
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4738
testb $0x1, -0xa9(%rbp)
jne 0xd272
jmp 0xd27e
movq -0xf8(%rbp), %rdi
callq 0x4260
jmp 0xd280
movq -0x38(%rbp), %rdi
callq 0x4620
nopl (%rax)
// File: princelab[P]emass/parser.cpp
// Function: Parser::write_compound(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&)
void Parser::write_compound(const wstring & frml, FormMap & c)
{
  c.clear();

  _tokenizer.set_input(frml);
  _tokenizer.get_token();
  Parser::ElementListNode * tmp = parse();
  
  if(_tokenizer._ttype != EOS) {
    delete tmp;	
    _tokenizer.error(L"End of input expected");
  }

  tmp->fill_compound(1, c);
  cleanUpFormula(c);
  delete tmp;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6c80
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xc720
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0xc770
movq -0x60(%rbp), %rdi
callq 0xcb90
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x20(%rbp)
cmpl $0x2, 0x8(%rax)
je 0xd38c
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xd30c
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdx
leaq 0x4e98(%rip), %rsi      # 0x121c8
leaq -0x40(%rbp), %rdi
callq 0xd6c0
jmp 0xd33b
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd030
jmp 0xd34a
leaq -0x40(%rbp), %rdi
callq 0x4738
leaq -0x41(%rbp), %rdi
callq 0x4640
jmp 0xd38c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd381
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4738
leaq -0x41(%rbp), %rdi
callq 0x4640
jmp 0xd3c9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
movl $0x1, %esi
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0xfb00
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xd3c0
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: princelab[P]emass/parser.cpp
// Function: Parser::ElementListNode::~ElementListNode()
Parser::ElementListNode::~ElementListNode()
{
  for(NodeList::iterator i = _NodeList.begin();
      i != _NodeList.end();
      ++i)
    {
      delete *i;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0xd805(%rip), %rax      # 0x1acd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xdc40
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xdca0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xdc70
testb $0x1, %al
jne 0xd503
jmp 0xd530
leaq -0x10(%rbp), %rdi
callq 0xdcd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xd523
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xd525
leaq -0x10(%rbp), %rdi
callq 0xdcf0
jmp 0xd4df
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xdc20
movq -0x20(%rbp), %rdi
callq 0xe200
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: princelab[P]emass/parser.cpp
// Function: Parser::ElementListNode::fill_compound(unsigned long, std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&) const
void Parser::ElementListNode::fill_compound(ulong weight, FormMap & c) const
{
  ulong totalweight = _count * weight;
  
  for(NodeList::const_iterator i = _NodeList.begin();
      i != _NodeList.end();
      ++i)
    {
      (*i)->fill_compound(totalweight, c);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x20(%rdi), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0xdd10
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xdd70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdd40
testb $0x1, %al
jne 0xd5da
jmp 0xd5ff
leaq -0x28(%rbp), %rdi
callq 0xdda0
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x28(%rbp), %rdi
callq 0xddd0
jmp 0xd5b6
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: princelab[P]emass/formula.cpp
// Function: cleanUpFormula(std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>>&)
void cleanUpFormula(FormMap & form) {
  
  typedef std::vector<size_t> Erasable;

  Erasable e;
  for(FormMap::iterator i = form.begin(); i != form.end(); ++i)
    if(i->second == 0)
      e.push_back(i->first);

  for(Erasable::iterator i = e.begin(); i != e.end(); ++i)
      form.erase(*i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xfdf0
movq -0x8(%rbp), %rdi
callq 0x6710
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6770
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6740
testb $0x1, %al
jne 0xfb42
jmp 0xfb8f
leaq -0x28(%rbp), %rdi
callq 0xfe10
cmpq $0x0, 0x8(%rax)
jne 0xfb82
leaq -0x28(%rbp), %rdi
callq 0xfe10
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0xfe30
jmp 0xfb69
jmp 0xfb82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xffb0
jmp 0xfbf7
jmp 0xfb84
leaq -0x28(%rbp), %rdi
callq 0xf1c0
jmp 0xfb22
leaq -0x20(%rbp), %rdi
callq 0xfea0
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xff10
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xfed0
testb $0x1, %al
jne 0xfbbc
jmp 0xfbe8
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xff70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xff40
jmp 0xfbdb
jmp 0xfbdd
leaq -0x48(%rbp), %rdi
callq 0xff90
jmp 0xfb9c
leaq -0x20(%rbp), %rdi
callq 0xffb0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4620
// File: princelab[P]emass/formula.cpp
// Function: isRealFormula(std::map<unsigned long, long, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, long>>> const&)
bool isRealFormula(const FormMap & form) {
  for(FormMap::const_iterator i = form.begin(); i != form.end(); ++i) {
    if(i->second < 0)
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x100a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10070
testb $0x1, %al
jne 0xfdb9
jmp 0xfddc
leaq -0x18(%rbp), %rdi
callq 0x100d0
cmpq $0x0, 0x8(%rax)
jge 0xfdcf
movb $0x0, -0x1(%rbp)
jmp 0xfde0
jmp 0xfdd1
leaq -0x18(%rbp), %rdi
callq 0x100f0
jmp 0xfd99
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BleuLlama[P]msf-tools/msf-dump.cpp
// Function: usage(char*)
void usage( char * av0 )
{
	std::cout << "Usage:  " << av0 << std::endl;
	std::cout << std::endl;
	std::cout << "note: define VOICERECORDER env var to set root path." << std::endl;
	std::cout << "  eg:" << std::endl;
	std::cout << "      export VOICERECORDER=/Volumes/IC_RECORDER" << std::endl;
	std::cout << "      export VOICERECORDER=/v/" << std::endl;
	std::cout << "      export VOICERECORDER=v:\\" << std::endl;

	std::cout << std::endl;
	std::cout << "Version 1.0  yorgle@gmail.com  Scott Lawrence" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x356d(%rip), %rdi      # 0x7fd0
leaq 0x7a2(%rip), %rsi       # 0x520c
callq 0x2170
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2170
movq %rax, %rdi
movq 0x353b(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x353f(%rip), %rdi      # 0x7fd0
movq 0x3528(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x352c(%rip), %rdi      # 0x7fd0
leaq 0x76a(%rip), %rsi       # 0x5215
callq 0x2170
movq %rax, %rdi
movq 0x3506(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x350a(%rip), %rdi      # 0x7fd0
leaq 0x77d(%rip), %rsi       # 0x524a
callq 0x2170
movq %rax, %rdi
movq 0x34e4(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x34e8(%rip), %rdi      # 0x7fd0
leaq 0x761(%rip), %rsi       # 0x5250
callq 0x2170
movq %rax, %rdi
movq 0x34c2(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x34c6(%rip), %rdi      # 0x7fd0
leaq 0x76f(%rip), %rsi       # 0x5280
callq 0x2170
movq %rax, %rdi
movq 0x34a0(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x34a4(%rip), %rdi      # 0x7fd0
leaq 0x76c(%rip), %rsi       # 0x529f
callq 0x2170
movq %rax, %rdi
movq 0x347e(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x3482(%rip), %rdi      # 0x7fd0
movq 0x346b(%rip), %rsi      # 0x7fc0
callq 0x2190
movq 0x346f(%rip), %rdi      # 0x7fd0
leaq 0x756(%rip), %rsi       # 0x52be
callq 0x2170
movq %rax, %rdi
movq 0x3449(%rip), %rsi      # 0x7fc0
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BleuLlama[P]msf-tools/msf-dump.cpp
// Function: main
int main( int argc, char ** argv )
{
	char * pth;

	pth = getenv( "VOICERECORDER" );
	if( !pth ) {
		usage( argv[0] );
		return -1;
	}

	// NOTE: on windows, put in a scan for a drive with label "IC_RECORDER"

	VoiceFile vf( pth );
	if( !vf.Valid() ) {
		std::cerr << "Directory is invalid: " << pth << std::endl;
		return -2;
	}

	int ret = vf.Dump();

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x73c(%rip), %rdi       # 0x52ec
callq 0x2220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4bd8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4a50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d62
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2300
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x2e10
jmp 0x4c12
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x31e0
jmp 0x4c27
leaq -0xa8(%rbp), %rdi
callq 0x20e0
leaq -0xa9(%rbp), %rdi
callq 0x21b0
leaq -0x88(%rbp), %rdi
callq 0x4d80
movb %al, -0xd9(%rbp)
jmp 0x4c53
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x4d23
jmp 0x4c63
movq 0x3386(%rip), %rdi      # 0x7ff0
leaq 0x689(%rip), %rsi       # 0x52fa
callq 0x2170
movq %rax, -0xe8(%rbp)
jmp 0x4c7f
movq -0xe8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2170
movq %rax, -0xf0(%rbp)
jmp 0x4c98
movq -0xf0(%rbp), %rdi
movq 0x331a(%rip), %rsi      # 0x7fc0
callq 0x2190
jmp 0x4cad
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl $0x1, -0xc0(%rbp)
jmp 0x4d56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4cf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x20e0
leaq -0xa9(%rbp), %rdi
callq 0x21b0
jmp 0x4d6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3770
jmp 0x4d6e
leaq -0x88(%rbp), %rdi
callq 0x37e0
movl %eax, -0xf4(%rbp)
jmp 0x4d37
movl -0xf4(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0xc4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3770
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x22f0
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/thread_x.c
// Function: flagging
static void*
flagging(void *_flag)
{
    FLAG    *flag = _flag;

    diag("\tflagging thread starts", flag);
    TRY(sleep(1));
    TRY(flag_any(flag));
    TRY(flag_all(flag));
    
    diag("\tthread exit");
    return _flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x3959(%rip), %rdi      # 0x7108
movb $0x0, %al
callq 0x3820
leaq 0x3963(%rip), %rdi      # 0x7120
movb $0x0, %al
callq 0x3820
movl $0x1, %edi
callq 0x3160
leaq 0x3955(%rip), %rdi      # 0x712a
movb $0x0, %al
callq 0x3820
movq -0x10(%rbp), %rdi
callq 0x5ad0
leaq 0x394e(%rip), %rdi      # 0x713a
movb $0x0, %al
callq 0x3820
movq -0x10(%rbp), %rdi
callq 0x5af0
leaq 0x3947(%rip), %rdi      # 0x714a
movb $0x0, %al
callq 0x3820
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/thread_x.c
// Function: diag
static void
diag(char const*fmt, ...) 
{
    va_list     ap;
    va_start(ap, fmt);
    fprintf(stderr, "%.6f ", tick() - start);
    vfprintf(stderr, fmt, ap);
    putc('\n', stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3855
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x673c(%rip), %rax      # 0x9fe0
movq %rax, -0xd8(%rbp)
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x5990
movq -0xe0(%rbp), %rdi
movsd 0x6f2f(%rip), %xmm1     # 0xa7f8
subsd %xmm1, %xmm0
leaq 0x382e(%rip), %rsi      # 0x7102
movb $0x1, %al
callq 0x3320
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x32e0
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3410
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/thread_x.c
// Function: sleeping
static void*
sleeping(void *arg)
{
    (void)arg;
    diag("\tsleeping thread starts");
    TRY(sleep(1));
    diag("\tNOTREACHED");
    return arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3834(%rip), %rdi      # 0x7157
movb $0x0, %al
callq 0x3820
leaq 0x37ef(%rip), %rdi      # 0x7120
movb $0x0, %al
callq 0x3820
movl $0x1, %edi
callq 0x3160
leaq 0x3826(%rip), %rdi      # 0x716f
movb $0x0, %al
callq 0x3820
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/thread.c
// Function: flag_destroy
void
flag_destroy(FLAG *flag)
{
    if (!flag) return;
    pthread_cond_destroy(&flag->cond);
    pthread_mutex_destroy(&flag->lock);
    free(flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5aa5
jmp 0x5ac4
movq -0x8(%rbp), %rdi
callq 0x3420
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3250
movq -0x8(%rbp), %rdi
callq 0x3280
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/thread.c
// Function: flag_watch
int
flag_watch(FLAG *flag, double waitsecs)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    waitsecs += tv.tv_sec + 1E-6*tv.tv_usec;

    struct timespec ts;
    ts.tv_sec = floor(waitsecs);
    ts.tv_nsec = (waitsecs - ts.tv_sec) * 1E9;

    pthread_mutex_lock(&flag->lock);
    errno = pthread_cond_timedwait(&flag->cond, &flag->lock, &ts);
    pthread_mutex_unlock(&flag->lock);

    return -!!errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3380
cvtsi2sdq -0x20(%rbp), %xmm1
cvtsi2sdq -0x18(%rbp), %xmm0
movsd 0x1c16(%rip), %xmm2     # 0x7758
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x33c0
cvttsd2si %xmm0, %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
cvtsi2sdq -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x1c02(%rip), %xmm1     # 0x7780
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3350
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
leaq -0x30(%rbp), %rdx
callq 0x3360
movl %eax, -0x34(%rbp)
callq 0x3050
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3170
callq 0x3050
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
subl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/thread.c
// Function: thread_start
THREAD*
thread_start(THREAD_FN func, void*arg)
{
    THREAD ret;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    errno = pthread_create(&ret.tid, &attr, func, arg);
    return errno ? NULL : memcpy(malloc(sizeof ret), &ret, sizeof ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x32a0
leaq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq 0x33e0
movl %eax, -0x54(%rbp)
callq 0x3050
movl -0x54(%rbp), %ecx
movl %ecx, (%rax)
callq 0x3050
cmpl $0x0, (%rax)
je 0x5c8d
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x5ca2
movl $0x8, %edi
callq 0x32d0
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/thread.c
// Function: thread_result
void*
thread_result(THREAD *pth)
{
    void *ret = NULL;
    errno = pthread_join(pth->tid, &ret); // EDEADLK...
    free(pth);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31c0
movl %eax, -0x14(%rbp)
callq 0x3050
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cpottamus[P]btree_lab/infodisk.cc
// Function: main
int main(int argc, char *argv[])
{
#if 0
  if (argc<2) { 
    usage();
    exit(-1);
  }
#endif

  DiskSystem disk(argv[1]);
  
  cerr << "Disk is as follows.\n" << disk << "\n";

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2370
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x2760
jmp 0x2617
movq %rsp, %rax
movl $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, (%rax)
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
xorl %r9d, %r9d
xorps %xmm2, %xmm2
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2ae0
jmp 0x2658
leaq -0xb0(%rbp), %rdi
callq 0x2100
leaq -0xb1(%rbp), %rdi
callq 0x2220
movq 0x6979(%rip), %rdi      # 0x8ff0
leaq 0x39a0(%rip), %rsi      # 0x601e
callq 0x21b0
movq %rax, -0xe0(%rbp)
jmp 0x268c
movq -0xe0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2810
movq %rax, -0xe8(%rbp)
jmp 0x26a8
movq -0xe8(%rbp), %rdi
leaq 0x3b46(%rip), %rsi      # 0x61fc
callq 0x21b0
jmp 0x26bd
movq 0x692c(%rip), %rdi      # 0x8ff0
leaq 0x3968(%rip), %rsi      # 0x6033
callq 0x21b0
jmp 0x26d2
movl $0x0, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3350
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x2723
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2100
leaq -0xb1(%rbp), %rdi
callq 0x2220
jmp 0x274f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3350
movq -0xc0(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: ParametrosDelSimClient::ParametrosDelSimClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, int, int, bool, unsigned int)
ParametrosDelSimClient::ParametrosDelSimClient(TopicName TN,bool s=false, int TV=0, int e=0, bool r=false, unsigned int t=10){
    topic_name=TN;
    subscriptor=s;
    topic_value=TV;
    error = e;
    retain = r;
    time_conection = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movb %r9b, %al
movl 0x10(%rbp), %r9d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x3290
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3030
jmp 0x3510
movq -0x48(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x24(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x2c(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3160
movq -0x28(%rbp), %rdi
callq 0x3340
nopl (%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: ParametrosDelSimClient::ParametrosDelSimClient(ParametrosDelSimClient const&)
ParametrosDelSimClient::ParametrosDelSimClient(const ParametrosDelSimClient &A){
    topic_name = A.topic_name;
    subscriptor = A.subscriptor;
    topic_value = A.topic_value;
    error=A.error;
    retain=A.retain;
    time_conection=A.time_conection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x3290
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3030
jmp 0x3593
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movb 0x2c(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x2c(%rax)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3160
movq -0x18(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::SubscribeNewTopic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SimPublisher::SubscribeNewTopic(TopicName tn){
    if (Par_del_client.subscriptor)
        brops->sendMsg(SubscribeMsg(tn));
    else{
        mutex_cout.lock();
        cout << "Error, you're only a Publisher" << endl;
        mutex_cout.unlock();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
testb $0x1, 0x78(%rax)
je 0x44c9
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x30e0
movq -0x88(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8620
jmp 0x4471
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
jmp 0x4487
leaq -0x40(%rbp), %rdi
callq 0x8690
leaq -0x60(%rbp), %rdi
callq 0x3160
jmp 0x4503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x44be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8690
leaq -0x60(%rbp), %rdi
callq 0x3160
jmp 0x450c
leaq 0x17d18(%rip), %rdi     # 0x1c1e8
callq 0x76c0
movq 0x17afc(%rip), %rdi     # 0x1bfd8
leaq 0xdd02(%rip), %rsi      # 0x121e5
callq 0x3200
movq %rax, %rdi
movq 0x17ace(%rip), %rsi     # 0x1bfc0
callq 0x3220
leaq 0x17cea(%rip), %rdi     # 0x1c1e8
callq 0x7720
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Client::insert_retainedTopic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::insert_retainedTopic (TopicName TN, TopicValue TV){
    if(Client_TopicName != TN)
        Assign_Client_TopicName(TN);
    B->Broker_Insert_Retained_Topic(TN,TV);
    warn_everybody_thisTopic(TN, TV);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xe0(%rbp)
movq %rdx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x7a30
testb $0x1, %al
jne 0x5652
jmp 0x56a3
movq -0xe0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x30e0
movq -0xd0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x5bf0
jmp 0x567e
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x56a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x57d0
movq -0xe0(%rbp), %rsi
movq -0xd0(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x30e0
movq -0xd8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x30e0
jmp 0x56da
movq -0xf0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x5c20
jmp 0x56f3
leaq -0x88(%rbp), %rdi
callq 0x3160
leaq -0x68(%rbp), %rdi
callq 0x3160
movq -0xe0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x30e0
movq -0xd8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x30e0
jmp 0x5730
movq -0xd0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x57e0
jmp 0x574c
leaq -0xc8(%rbp), %rdi
callq 0x3160
leaq -0xa8(%rbp), %rdi
callq 0x3160
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3160
leaq -0x68(%rbp), %rdi
callq 0x3160
jmp 0x57d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x57c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x3160
leaq -0xa8(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3340
nopl (%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Client::insert_subscriber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::insert_subscriber(TopicName TN){
    list<TopicName>::iterator it=Lista_Topics_subscriptos.begin();
    for (; it!=Lista_Topics_subscriptos.end(); ++it){}
    if( it == Lista_Topics_subscriptos.end()){
            Lista_Topics_subscriptos.insert(Lista_Topics_subscriptos.begin(),TN);
            B->Broker_insert_subscriber(TN, this); // subscribir el Client en el map(subscriptos) del broker
        }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
callq 0x7a60
movq %rax, -0x18(%rbp)
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x7ac0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7a90
testb $0x1, %al
jne 0x58e0
jmp 0x58ed
jmp 0x58e2
leaq -0x18(%rbp), %rdi
callq 0x7af0
jmp 0x58bc
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x7ac0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7b10
testb $0x1, %al
jne 0x5914
jmp 0x59b2
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x98(%rbp)
callq 0x7a60
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7bb0
movq -0x98(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq -0x30(%rbp), %rsi
callq 0x7b40
movq -0x80(%rbp), %rsi
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x30e0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x5c90
jmp 0x5990
leaq -0x60(%rbp), %rdi
callq 0x3160
jmp 0x59b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3160
jmp 0x59bb
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Client::unsuscribe_topic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::unsuscribe_topic(TopicName TN){
    for (list<TopicName>::iterator it=Lista_Topics_subscriptos.begin(); it!=Lista_Topics_subscriptos.end(); ++it){
        if(*it == TN){
            it=Lista_Topics_subscriptos.erase(it);
            B->Broker_unsuscribe_topic(TN, this);
        }
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
callq 0x7a60
movq %rax, -0x18(%rbp)
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
callq 0x7ac0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7a90
testb $0x1, %al
jne 0x5a23
jmp 0x5ade
leaq -0x18(%rbp), %rdi
callq 0x7bd0
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x79a0
testb $0x1, %al
jne 0x5a41
jmp 0x5ace
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7bb0
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7bf0
movq -0x70(%rbp), %rsi
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x30e0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x6080
jmp 0x5aac
leaq -0x50(%rbp), %rdi
callq 0x3160
jmp 0x5ace
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3160
jmp 0x5ae7
jmp 0x5ad0
leaq -0x18(%rbp), %rdi
callq 0x7af0
jmp 0x59fc
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3340
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::ClientDestruction(Client*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Broker::ClientDestruction(Client * C, TopicName TN){
    this_thread::sleep_for (std::chrono::seconds(5));
    RetainedTopics.erase(TN);
    delete(C);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x5, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x71d0
leaq -0x20(%rbp), %rdi
callq 0x7120
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x38, %rdi
callq 0x7f10
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5be6
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::Broker_Insert_Retained_Topic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Broker::Broker_Insert_Retained_Topic (TopicName TN, TopicValue TV){
    m_retainedTopics.lock();
    RetainedTopics[TN]=TV;
    m_retainedTopics.unlock();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xd0, %rdi
callq 0x76c0
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x7f40
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x3030
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0x7720
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::Broker_insert_subscriber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Client*)
void Broker::Broker_insert_subscriber(TopicName TN, Client *C){
    m_subscriptos.lock();
    subscriptos.insert({TN,C});
    m_subscriptos.unlock();
    m_retainedTopics.lock();
    auto it = RetainedTopics.find(TN);
    if ( !(it == RetainedTopics.end())) // si ya hay un topic de esto retenido, mandarlo al SimClient
        C->getCif()->recvMsg(PublishMsg(it->first, it->second));
    m_retainedTopics.unlock();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
addq $0xf8, %rdi
callq 0x76c0
movq -0x128(%rbp), %rax
movq -0x120(%rbp), %rsi
addq $0x70, %rax
movq %rax, -0x118(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x81e0
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0x81b0
movq %rax, -0x108(%rbp)
jmp 0x5d0e
movq -0x108(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8220
movq -0x128(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7720
movq -0x128(%rbp), %rdi
addq $0xd0, %rdi
callq 0x76c0
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
addq $0x38, %rdi
callq 0x8240
movq -0x128(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x38, %rdi
callq 0x82a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8270
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d8f
jmp 0x5ea0
movq -0x18(%rbp), %rdi
callq 0x8010
movq %rax, -0x138(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x82d0
movq %rax, %rsi
leaq -0xe0(%rbp), %rdi
callq 0x30e0
movq -0x130(%rbp), %rdi
callq 0x82d0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x100(%rbp), %rdi
callq 0x30e0
jmp 0x5ddf
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0x100(%rbp), %rdx
xorl %ecx, %ecx
callq 0x8030
jmp 0x5dfd
movq -0x138(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
leaq -0xc0(%rbp), %rsi
callq *%rax
jmp 0x5e15
leaq -0xc0(%rbp), %rdi
callq 0x80f0
leaq -0x100(%rbp), %rdi
callq 0x3160
leaq -0xe0(%rbp), %rdi
callq 0x3160
jmp 0x5ea0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8220
jmp 0x5ebc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5e92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x80f0
leaq -0x100(%rbp), %rdi
callq 0x3160
leaq -0xe0(%rbp), %rdi
callq 0x3160
jmp 0x5ebc
movq -0x128(%rbp), %rdi
addq $0xd0, %rdi
callq 0x7720
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::Broker_warn_everybody_thisTopic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Broker::Broker_warn_everybody_thisTopic (TopicName Tn, TopicValue Tv){
    m_subscriptos.lock();
    auto its = subscriptos.equal_range(Tn); // encuentra todos los Client para un dado TopicName
    for (auto it = its.first; it != its.second; ++it) {
        // Le manda un publish a cada SimClient con el value del topic encontrado
        it->second->getCif()->recvMsg(PublishMsg(Tn, Tv)); // Si reemplazo cif por getCif() el proceso no devuelve todo el output
    }
    m_subscriptos.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xe0(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
addq $0xf8, %rdi
callq 0x76c0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
addq $0x70, %rdi
callq 0x7f70
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x7fb0
testb $0x1, %al
jne 0x5f4d
jmp 0x6056
leaq -0x30(%rbp), %rdi
callq 0x7fe0
movq 0x20(%rax), %rdi
callq 0x8010
movq -0xe0(%rbp), %rsi
movq %rax, -0xf8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x30e0
movq -0xf0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x30e0
jmp 0x5f8e
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
xorl %ecx, %ecx
callq 0x8030
jmp 0x5fac
movq -0xf8(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
leaq -0x88(%rbp), %rsi
callq *%rax
jmp 0x5fc4
leaq -0x88(%rbp), %rdi
callq 0x80f0
leaq -0xc8(%rbp), %rdi
callq 0x3160
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0x30(%rbp), %rdi
callq 0x8140
jmp 0x5f33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x6048
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x603c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x80f0
leaq -0xc8(%rbp), %rdi
callq 0x3160
leaq -0xa8(%rbp), %rdi
callq 0x3160
jmp 0x6072
movq -0xe8(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7720
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x3340
nop
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::Broker_unsuscribe_topic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Client*)
void Broker::Broker_unsuscribe_topic(TopicName TN, Client *C){
    m_subscriptos.lock();
    // para un dado TopicName, encuentra todos los Clientes del map(subscriptores) del broker y los pone en its
    auto its = subscriptos.equal_range(TN);
    // Busco el client "This" entre los Client en "its" y lo remuevo del map
    auto it = its.first;
    for (; it != its.second && it->second != C; ++it){}
    if(it->second==C) //NOSE PORQUE ESTO NO ANDA SI NO ESTOY SUBSCRIPTO(SEG FAULT)
        subscriptos.erase(it);
    m_subscriptos.unlock();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0xf8, %rdi
callq 0x76c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x70, %rdi
callq 0x7f70
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x7fb0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0x60ec
jmp 0x6103
leaq -0x30(%rbp), %rdi
callq 0x7fe0
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x610c
jmp 0x6119
jmp 0x610e
leaq -0x30(%rbp), %rdi
callq 0x8140
jmp 0x60cd
leaq -0x30(%rbp), %rdi
callq 0x7fe0
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x6149
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x8170
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7720
addq $0x60, %rsp
popq %rbp
retq
nop
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::~Broker()
Broker::~Broker(){

    unordered_map<ClientOpsIF *, Client *> ::iterator it = clients.begin();
    while(it != clients.end()){
	    delete(it->second);
	    it++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7c90
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7cc0
testb $0x1, %al
jne 0x619d
jmp 0x61cf
leaq -0x10(%rbp), %rdi
callq 0x7d20
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x61be
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7d50
movq %rax, -0x20(%rbp)
jmp 0x617d
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
callq 0x7d80
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x7da0
movq -0x28(%rbp), %rdi
callq 0x7dc0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: Broker::registerClient(ClientOpsIF*)
BrokerOpsIF * Broker::registerClient(ClientOpsIF *c){
    m_clients.lock();
    unordered_map<ClientOpsIF *, Client *>::const_iterator got = clients.find (c);
    // if Client is not register, register it in the map(clients) of broker and give it the pointer
    if ( got == clients.end() || got->second == nullptr){
        Client *Br = new Client(c);
        clients.insert ( {c,Br} );
        m_clients.unlock();
        return (BrokerOpsIF *) Br;
    } 
    else{ //if it is registered, and has a client, give it to him
        m_clients.unlock();
        return (BrokerOpsIF *)got->second;
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0xa8, %rdi
callq 0x76c0
movq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7de0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7e10
movq -0x78(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7e40
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x627f
leaq -0x20(%rbp), %rdi
callq 0x7e70
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x6288
jmp 0x6305
movl $0x178, %edi            # imm = 0x178
callq 0x3210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4640
jmp 0x62a7
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x7ee0
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7ea0
movq -0x78(%rbp), %rdi
movq %rax, -0x68(%rbp)
movb %dl, -0x60(%rbp)
addq $0xa8, %rdi
callq 0x7720
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6326
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x31f0
jmp 0x6333
movq -0x78(%rbp), %rdi
addq $0xa8, %rdi
callq 0x7720
leaq -0x20(%rbp), %rdi
callq 0x7e70
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3340
nopl (%rax)