LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x6c90
cmpq $0x0, 0x28(%rax)
setns %bpl
js 0x6c93
movq %rax, %rdi
callq 0x3340
cmpq %rbx, %rax
jne 0x6c76
jmp 0x6c93
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x2f4e(%rip), %rbx      # 0x6fd0
leaq 0x1183(%rip), %rsi      # 0x520c
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2130
testq %r14, %r14
je 0x40b7
movq %r14, %rdi
callq 0x2070
movq 0x2f26(%rip), %rdi      # 0x6fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2130
jmp 0x40ce
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10f2(%rip), %rsi      # 0x5215
movl $0x34, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10ec(%rip), %rsi      # 0x524a
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10b7(%rip), %rsi      # 0x5250
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10ac(%rip), %rsi      # 0x5280
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x1090(%rip), %rsi      # 0x529f
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x104d(%rip), %rsi      # 0x52be
movl $0x2d, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
leaq 0x102a(%rip), %rdi      # 0x52ec
callq 0x2160
testq %rax, %rax
je 0x432c
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x2070
movq %rbx, %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x2dac
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4317
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2110
cmpb $0x0, 0x20(%rsp)
je 0x433b
leaq 0x20(%rsp), %rdi
callq 0x329a
movl %eax, %ebx
jmp 0x43a0
movq (%r14), %rdi
callq 0x4074
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x43aa
movq 0x2cae(%rip), %rdi      # 0x6ff0
leaq 0xfb1(%rip), %rsi       # 0x52fa
movl $0x16, %edx
callq 0x2130
movq %rbx, %rdi
callq 0x2070
movq 0x2c8e(%rip), %r14      # 0x6ff0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2130
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq 0x2c62(%rip), %rdi      # 0x6ff0
callq 0x2040
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %rax, %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x3234
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x43d6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x43e3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2110
jmp 0x43e3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3234
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/thread_x.c
// Function: main
int main(void)
{
    start = tick();
    setvbuf(stderr, NULL, _IOLBF, 0);

    FLAG   *flag = flag_create();
    THREAD *thrd = thread_start(flagging, flag);

    int rc;
#undef  TRY
#define TRY(x) diag(#x " ...\n"); rc = (intptr_t)(x); diag(#x ": %d %s", rc, errname[errno])
    TRY(flag_watch(flag, 0));
    TRY(flag_watch(flag, 0.5));
    TRY(flag_watch(flag, 0.5));
    TRY(sleep(1));

    thread_result(thrd);

    thrd = thread_start(sleeping, flag);
    TRY(thread_cancel(thrd));
    TRY(thread_result(thrd));

    flag_destroy(flag);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x4945
movsd %xmm0, 0x60f4(%rip)     # 0x97d8
movq 0x58f5(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3040
callq 0x4974
movq %rax, %rbx
leaq 0x17b(%rip), %rdi       # 0x3886
movq %rax, %rsi
callq 0x4ab5
movq %rax, %r15
leaq 0x28f3(%rip), %rdi      # 0x6010
xorl %eax, %eax
callq 0x3440
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x49ae
movl %eax, %ebp
callq 0x3050
movq %rax, %r14
movslq (%rax), %rax
leaq 0x5aed(%rip), %rcx      # 0x9230
movq (%rcx,%rax,8), %rdx
movq %rcx, %r13
leaq 0x28d8(%rip), %rdi      # 0x6029
movl %ebp, %esi
xorl %eax, %eax
callq 0x3440
leaq 0x28e3(%rip), %r12      # 0x6044
movq %r12, %rdi
xorl %eax, %eax
callq 0x3440
movsd 0x2895(%rip), %xmm0     # 0x6008
movq %rbx, %rdi
callq 0x49ae
movslq (%r14), %rcx
movq %r13, %rbp
movq (%r13,%rcx,8), %rdx
leaq 0x28d2(%rip), %r13      # 0x605f
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
movq %r12, %rdi
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
movsd 0x285a(%rip), %xmm0     # 0x6008
callq 0x49ae
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
leaq 0x28ae(%rip), %rdi      # 0x607c
xorl %eax, %eax
callq 0x3440
movl $0x1, %edi
callq 0x3150
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x289c(%rip), %rdi      # 0x608a
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
movq %r15, %rdi
callq 0x4b28
leaq -0x2ed(%rip), %rdi      # 0x3519
movq %rbx, %rsi
callq 0x4ab5
movq %rax, %r15
leaq 0x2882(%rip), %rdi      # 0x609a
xorl %eax, %eax
callq 0x3440
movq %r15, %rdi
callq 0x4b0e
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x287d(%rip), %rdi      # 0x60b3
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
leaq 0x2888(%rip), %rdi      # 0x60ce
xorl %eax, %eax
callq 0x3440
movq %r15, %rdi
callq 0x4b28
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x2883(%rip), %rdi      # 0x60e7
movl %eax, %esi
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
callq 0x4983
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x2877(%rip), %rdi      # 0x6108
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3440
leaq 0x287e(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x3440
movl $0x1, %edi
callq 0x3150
leaq 0x2870(%rip), %rdi      # 0x612a
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
callq 0x49a4
leaq 0x286a(%rip), %rdi      # 0x613a
xorl %eax, %eax
callq 0x3440
movq %rbx, %rdi
callq 0x49a9
leaq 0x2864(%rip), %rdi      # 0x614a
xorl %eax, %eax
callq 0x3440
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x49a3
pushq %rbx
movq %rdi, %rbx
callq 0x3400
leaq 0x30(%rbx), %rdi
callq 0x3240
movq %rbx, %rdi
popq %rbx
jmp 0x3270
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3290
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33c0
movl %eax, %ebx
callq 0x3050
movl %ebx, (%rax)
testl %ebx, %ebx
je 0x4af3
xorl %eax, %eax
jmp 0x4b04
movl $0x8, %edi
callq 0x32c0
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0xb0, %rsp
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x25be
subq $0x8, %rsp
xorl %eax, %eax
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2694
addq $0x20, %rsp
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2519
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x5ad0(%rip), %rdi      # 0x7ff0
leaq 0x2af7(%rip), %rsi      # 0x501e
movl $0x14, %edx
callq 0x21d0
movq 0x5ab8(%rip), %rsi      # 0x7ff0
leaq 0x30(%rsp), %rdi
callq 0x3a12
leaq 0x2cb3(%rip), %rsi      # 0x51fc
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x5a93(%rip), %rdi      # 0x7ff0
leaq 0x2acf(%rip), %rsi      # 0x5033
movl $0x6, %edx
callq 0x21d0
leaq 0x30(%rsp), %rdi
callq 0x2c34
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25b5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x25b5
movq %rax, %rbx
jmp 0x25b5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2c34
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpb $0x1, 0x78(%rdi)
jne 0x41a7
movq 0xf8(%rdi), %rbx
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x742a
leaq 0x8b04(%rip), %r13      # 0xcc48
leaq -0x48(%rbp), %rdi
movq %r13, -0x10(%rdi)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x742a
leaq -0x58(%rbp), %rsi
movl $0x3, 0x8(%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r13, -0x58(%rbp)
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x418a
callq 0x31c0
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x4198
callq 0x31c0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9002(%rip), %rdi      # 0xd1b0
callq 0x3270
testl %eax, %eax
jne 0x4213
movq 0x8e1a(%rip), %rbx      # 0xcfd8
leaq 0x501c(%rip), %rsi      # 0x91e1
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x3200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
leaq 0x8fb0(%rip), %rdi      # 0xd1b0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movl %eax, %edi
callq 0x3140
movq %rax, %rbx
movq %r13, -0x58(%rbp)
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x4234
callq 0x31c0
jmp 0x4234
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x4242
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
leaq 0x118(%rdi), %r14
movq %rdi, -0x30(%rbp)
movq 0x120(%rdi), %rdx
movq 0x8(%rsi), %r13
cmpq %r13, %rdx
jne 0x515d
testq %rdx, %rdx
je 0x519a
movq (%r15), %rbx
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x31f0
testl %eax, %eax
jne 0x5160
jmp 0x519a
movq (%r15), %rbx
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
addq %rbx, %r13
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x742a
movq %r14, %rdi
movq %r12, %rsi
callq 0x3120
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x519a
callq 0x31c0
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r12
leaq -0xc8(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0xd8(%rbp), %rdi
callq 0x742a
leaq -0xa8(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq -0x38(%rbp), %r14
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xb8(%rbp), %rdi
callq 0x742a
leaq -0xd8(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
movq %r12, %rdi
callq 0x5646
movq -0xb8(%rbp), %rdi
cmpq %rbx, %rdi
je 0x520f
callq 0x31c0
movq -0xd8(%rbp), %rdi
cmpq %r13, %rdi
je 0x5220
callq 0x31c0
leaq -0x88(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x742a
leaq -0x68(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x742a
leaq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x530a
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x527f
callq 0x31c0
movq -0x98(%rbp), %rdi
cmpq %r12, %rdi
je 0x5290
callq 0x31c0
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
jne 0x52fd
jmp 0x5302
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x52ca
callq 0x31c0
jmp 0x52ca
movq %rax, %r14
movq -0x98(%rbp), %rdi
cmpq %r12, %rdi
jne 0x52fd
jmp 0x5302
movq %rax, %r14
movq -0xb8(%rbp), %rdi
cmpq %rbx, %rdi
je 0x52f1
callq 0x31c0
jmp 0x52f1
movq %rax, %r14
movq -0xd8(%rbp), %rdi
cmpq %r13, %rdi
je 0x5302
callq 0x31c0
movq %r14, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rbx), %r15
callq 0x7ba6
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x18(%rbx)
movq 0x20(%rbx), %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x742a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x569e
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5430
callq 0x31c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x544e
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x8(%rdi), %r14
movq %rdi, -0x38(%rbp)
movq 0x8(%rdi), %r13
cmpq %r14, %r13
je 0x5514
movq %rsi, %rbx
movq %r14, -0x30(%rbp)
movq -0x38(%rbp), %r15
movq 0x18(%r13), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x54a6
testq %rdx, %rdx
je 0x54ab
movq (%rbx), %rsi
movq 0x10(%r13), %rdi
callq 0x31f0
testl %eax, %eax
je 0x54ab
movq %r13, %r12
jmp 0x5507
movq (%r13), %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x7bf4
movq 0x20(%r15), %rax
movq %rax, -0x40(%rbp)
leaq -0x50(%rbp), %r14
movq %r14, -0x60(%rbp)
movq (%rbx), %rsi
movq %rbx, %r13
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x742a
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x59e4
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x5500
callq 0x31c0
movq -0x30(%rbp), %r14
movq %r13, %rbx
movq (%r12), %r13
cmpq %r14, %r13
jne 0x5487
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x5534
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x30(%rbp), %r12
movq $0x5, (%r12)
movq $0x0, 0x8(%r12)
movq %r12, %rdi
movq %r12, %rsi
callq 0x30b0
cmpl $-0x1, %eax
jne 0x5609
callq 0x3040
cmpl $0x4, (%rax)
je 0x55ef
addq $0x38, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7f44
testq %rbx, %rbx
je 0x5626
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xd0(%rdi), %rbx
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
jne 0x5697
addq $0x38, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8128
movq %rax, %rdi
movq %r14, %rsi
callq 0x3120
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movl %eax, %edi
callq 0x3140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
addq $0xf8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3270
testl %eax, %eax
jne 0x580d
leaq 0x70(%r12), %r13
leaq -0xc0(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0xd0(%rbp), %r14
movq %r14, %rdi
callq 0x742a
movq %rbx, -0x30(%rbp)
movq %rbx, 0x20(%r14)
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x86f6
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x5729
callq 0x31c0
movq -0x38(%rbp), %rdi
callq 0x3170
leaq 0xd0(%r12), %rbx
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
movq -0x30(%rbp), %r14
jne 0x580d
addq $0x38, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8b26
testq %rax, %rax
je 0x57f3
movq %rax, %r15
movq 0x30(%r14), %r14
leaq -0x68(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x742a
leaq -0x48(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x742a
leaq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
xorl %ecx, %ecx
callq 0x6a96
movq (%r14), %rax
leaq -0xd0(%rbp), %rsi
movq %r14, %rdi
callq *(%rax)
leaq -0xd0(%rbp), %rdi
callq 0x6b28
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x57e5
callq 0x31c0
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x57f3
callq 0x31c0
movq %rbx, %rdi
callq 0x3170
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x6b28
jmp 0x5828
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x583b
callq 0x31c0
jmp 0x583b
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x5849
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
jne 0x5844
jmp 0x5849
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
addq $0xf8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3270
testl %eax, %eax
jne 0x5995
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, -0x40(%rbp)
movq %rbx, %rsi
callq 0x8484
movq %rdx, -0x38(%rbp)
cmpq %rdx, %rax
je 0x597a
movq %rax, %r12
leaq -0x68(%rbp), %rbx
leaq -0x88(%rbp), %r15
leaq -0xe0(%rbp), %r14
movq 0x28(%r12), %rax
movq 0x30(%rax), %r13
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x742a
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x742a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x6a96
movq (%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
callq *(%rax)
movq %r14, %rdi
callq 0x6b28
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x5956
callq 0x31c0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x5968
callq 0x31c0
movq (%r12), %r12
cmpq -0x38(%rbp), %r12
leaq -0x68(%rbp), %rbx
jne 0x58d5
movq -0x30(%rbp), %rdi
callq 0x3170
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
movq %rax, %rbx
jmp 0x59ca
movq %rax, %rbx
jmp 0x59b5
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x6b28
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x59ca
callq 0x31c0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x59dc
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xf8(%rdi), %rbx
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
jne 0x5a4b
addq $0x70, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x8484
cmpq %rdx, %rax
je 0x5a2a
cmpq %r15, 0x28(%rax)
je 0x5a2a
movq (%rax), %rax
jmp 0x5a1a
cmpq %r15, 0x28(%rax)
jne 0x5a3b
movq %r14, %rdi
movq %rax, %rsi
callq 0x8620
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movl %eax, %edi
callq 0x3140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x5a79
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x5a74
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
jmp 0x5a60
leaq 0x70(%rbx), %rdi
callq 0x6e02
leaq 0x38(%rbx), %rdi
callq 0x6ea2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6f7e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, -0x20(%rbp)
leaq 0xa8(%rdi), %rbx
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
jne 0x5b2e
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x7c2a
testq %rax, %rax
je 0x5ae8
movq %rax, %r15
cmpq $0x0, 0x10(%rax)
je 0x5ae8
movq %rbx, %rdi
callq 0x3170
movq 0x10(%r15), %r15
jmp 0x5b20
movl $0x178, %edi            # imm = 0x178
callq 0x31e0
movq %rax, %r15
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x434e
movq -0x20(%rbp), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq %r14, %rdi
callq 0x7c8c
movq %rbx, %rdi
callq 0x3170
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
movq %rax, %rbx
movq %r15, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::Publish()
void SimPublisher::Publish (void){
        // Empezar a publicar valores
    for (unsigned int i=0; i<Par_del_client.time_conection; ++i){
        std::this_thread::sleep_for (std::chrono::seconds(1));
        brops->sendMsg(PublishMsg(Par_del_client.topic_name, to_string(rand()%Par_del_client.error - Par_del_client.error/2 + Par_del_client.topic_value), Par_del_client.retain));
    }
    // Disconnect luego del tiempo de vida
    brops->sendMsg(DisconnectMsg{});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r12
cmpl $0x0, 0x88(%rdi)
je 0x61c6
leaq -0x70(%rbp), %r15
xorl %ebx, %ebx
leaq -0xd8(%rbp), %r14
leaq -0x80(%rbp), %r13
movq %r12, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq $0x1, -0xd8(%rbp)
movq $0x0, -0xd0(%rbp)
movq %r14, %rdi
movq %r14, %rsi
callq 0x30b0
cmpl $-0x1, %eax
jne 0x6082
callq 0x3040
cmpl $0x4, (%rax)
je 0x6068
movq 0xf8(%r12), %rax
movq %rax, -0x40(%rbp)
movq %r15, -0x80(%rbp)
movq 0x58(%r12), %rsi
movq 0x60(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x742a
callq 0x3070
movl 0x80(%r12), %ecx
cltd
idivl %ecx
movl %edx, %r15d
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
subl %eax, %r15d
addl 0x7c(%r12), %r15d
movl %r15d, %r12d
negl %r12d
cmovsl %r15d, %r12d
movl $0x1, %r13d
cmpl $0xa, %r12d
leaq -0x60(%rbp), %rbx
jb 0x612c
movl $0x4, %r13d
movl %r12d, %eax
movl $0xd1b71759, %edx       # imm = 0xD1B71759
cmpl $0x63, %eax
jbe 0x6123
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x6129
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x612c
movl %eax, %ecx
imulq %rdx, %rcx
shrq $0x2d, %rcx
addl $0x4, %r13d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x60f3
addl $-0x3, %r13d
jmp 0x612c
addl $-0x2, %r13d
jmp 0x612c
decl %r13d
shrl $0x1f, %r15d
leal (%r15,%r13), %esi
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x3210
movl %r15d, %edi
addq -0x60(%rbp), %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x72ab
movq -0x38(%rbp), %r12
movzbl 0x84(%r12), %ecx
movq %r14, %rdi
leaq -0x80(%rbp), %r13
movq %r13, %rsi
movq %rbx, %rdx
callq 0x6a96
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
leaq -0x70(%rbp), %r15
callq *0x10(%rax)
movq %r14, %rdi
callq 0x6b28
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x61a5
callq 0x31c0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
movl -0x2c(%rbp), %ebx
je 0x61b6
callq 0x31c0
incl %ebx
cmpl 0x88(%r12), %ebx
jb 0x604f
movq 0xf8(%r12), %rdi
leaq 0x6ab3(%rip), %rax      # 0xcc88
leaq -0xd8(%rbp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movq (%rdi), %rax
callq *0x10(%rax)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6229
movq %rax, %rbx
jmp 0x6217
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x6b28
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x6229
callq 0x31c0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x623b
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::recvMsg(Message const&)
void SimPublisher::recvMsg(const Message &m){
    switch (m.getType()){
        case Message::Type::CONNACK:
        {
            ConnAckMsg *M = (ConnAckMsg *)&m;
            recvConnack(M);
            break;
        }
        case Message::Type::PUBLISH:{
            PublishMsg *M = (PublishMsg *)&m;
            recvPublishMsg(M);
            break;
        }
        default:{ // Cualquier otro tipo de mensae recibido es indeseado
            mutex_cout.lock();
            cout << "Error al recibir Mensaje del Client: " << usuario_pass.username << endl;
            mutex_cout.unlock();
            return;}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
je 0x633b
cmpl $0x1, %eax
jne 0x6347
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x63c4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6502
leaq 0x6e62(%rip), %rdi      # 0xd1b0
callq 0x3270
testl %eax, %eax
jne 0x63bc
movq 0x6c7a(%rip), %r14      # 0xcfd8
leaq 0x2e9b(%rip), %rsi      # 0x9200
movl $0x25, %edx
movq %r14, %rdi
callq 0x3200
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x3200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
leaq 0x6dfd(%rip), %rdi      # 0xd1b0
popq %rbx
popq %r14
popq %rbp
jmp 0x3170
movl %eax, %edi
callq 0x3140
nop
// File: /workspace/github_cpp_makefile_star2_O3/andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::recvConnack(ConnAckMsg*)
void SimPublisher::recvConnack(ConnAckMsg *M){
    
    switch ((int)(M->getStatusType())){
        case 0: // LOGIN_OK
        {
            mutex_cout.lock();
            cout << "From Client\tMessage: CONNACK\tto: "<< usuario_pass.username << " -> OK" << endl;
            mutex_cout.unlock();
            connack_value = true;
            ready = true;
            cond_var.notify_one();
            break;
        }
        case 1:{ // LOGIN ERROR
            mutex_cout.lock();
            cout << "From Client\tMessage: CONNACK\tto: "<< usuario_pass.username << " -> ERROR" << endl;
            mutex_cout.unlock();
            connack_value = false;
            ready = true;
            cond_var.notify_one();
            break;}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rsi), %eax
cmpl $0x1, %eax
je 0x643c
testl %eax, %eax
jne 0x64ef
leaq 0x6dc8(%rip), %rdi      # 0xd1b0
callq 0x3270
testl %eax, %eax
jne 0x64fa
movq 0x6bdc(%rip), %r14      # 0xcfd8
leaq 0x2e23(%rip), %rsi      # 0x9226
movl $0x21, %edx
movq %r14, %rdi
callq 0x3200
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x3200
movq %rax, %r14
leaq 0x2e1e(%rip), %rsi      # 0x9248
movl $0x6, %edx
movq %rax, %rdi
callq 0x3200
movb $0x1, %r15b
jmp 0x6495
leaq 0x6d6d(%rip), %rdi      # 0xd1b0
callq 0x3270
testl %eax, %eax
jne 0x64fa
movq 0x6b81(%rip), %r14      # 0xcfd8
leaq 0x2dc8(%rip), %rsi      # 0x9226
movl $0x21, %edx
movq %r14, %rdi
callq 0x3200
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x3200
movq %rax, %r14
leaq 0x2dca(%rip), %rsi      # 0x924f
movl $0x9, %edx
movq %rax, %rdi
callq 0x3200
xorl %r15d, %r15d
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
leaq 0x6ced(%rip), %rdi      # 0xd1b0
callq 0x3170
movb %r15b, 0x90(%rbx)
movb $0x1, 0xf0(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3100
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
nop
// File: /workspace/github_cpp_makefile_star2_O3/andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::recvPublishMsg(PublishMsg*) const
void SimPublisher::recvPublishMsg(PublishMsg *M) const{
    mutex_cout.lock();
    cout << "From Client\tMessage: PUBLISH\tto: "<< usuario_pass.username <<"\t" << "Topic " << M->getTopic() << ": " << M->getValue() << endl;
    mutex_cout.unlock();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6c92(%rip), %rdi      # 0xd1b0
callq 0x3270
testl %eax, %eax
jne 0x6652
movq 0x6aa6(%rip), %r15      # 0xcfd8
leaq 0x2d20(%rip), %rsi      # 0x9259
movl $0x21, %edx
movq %r15, %rdi
callq 0x3200
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
callq 0x3200
movq %rax, %r14
leaq 0x2bb8(%rip), %rsi      # 0x9118
movl $0x1, %edx
movq %rax, %rdi
callq 0x3200
leaq 0x2ba6(%rip), %rsi      # 0x911a
movl $0x6, %edx
movq %r14, %rdi
callq 0x3200
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x742a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3200
movq %rax, %r14
leaq 0x2b8d(%rip), %rsi      # 0x9147
movl $0x2, %edx
movq %rax, %rdi
callq 0x3200
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x742a
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0x3200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x662b
callq 0x31c0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x6639
callq 0x31c0
leaq 0x6b70(%rip), %rdi      # 0xd1b0
callq 0x3170
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x665b
movq %rax, %rbx
jmp 0x6671
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x6671
callq 0x31c0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x667f
callq 0x31c0
movq %rbx, %rdi
callq 0x32e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/andresziemecki[P]MQTT/./queue.h
// Function: cola<Message*, 100ul>::push(Message* const&)
void push(const T &t)
		{
			unique_lock<mutex> lock(m);
			while( q.size() == N ){
			  cond_var_put.wait(lock);
			}
			q.push(t);
			lock.unlock();
			cond_var_get.notify_one();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x8baa
movb $0x1, 0x8(%r15)
leaq 0x78(%rbx), %r12
movq 0x48(%rbx), %rax
movq %rax, %rcx
subq 0x28(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0x30(%rbx), %rax
movq %rax, %rdx
subq 0x38(%rbx), %rdx
movq 0x20(%rbx), %rsi
sarq $0x3, %rdx
subq 0x10(%rbx), %rsi
sarq $0x3, %rsi
addq %rdx, %rsi
addq %rcx, %rsi
cmpq $0x64, %rsi
jne 0x68bf
movq %r12, %rdi
movq %r15, %rsi
callq 0x30a0
jmp 0x6870
movq 0x40(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x68d9
movq (%r14), %rcx
movq %rcx, (%rax)
addq $0x8, 0x30(%rbx)
jmp 0x68e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x77ac
leaq -0x30(%rbp), %rdi
callq 0x777a
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x6d08
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x6d08
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/andresziemecki[P]MQTT/./queue.h
// Function: cola<Message*, 100ul>::pop(Message**)
void pop(T *t)
		{
			unique_lock<mutex>lock(m);
			while(q.size() == 0){
				cond_var_get.wait(lock);
			}
			lock.unlock();
			cond_var_put.notify_one();
			*t = q.front();
			q.pop();
			return;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x8baa
movb $0x1, 0x8(%r15)
leaq 0xa8(%rbx), %r12
movq 0x48(%rbx), %rax
movq %rax, %rcx
subq 0x28(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rdx
subq 0x38(%rbx), %rdx
sarq $0x3, %rdx
addq %rcx, %rdx
subq 0x10(%rbx), %rax
sarq $0x3, %rax
addq %rdx, %rax
jne 0x69a7
movq %r12, %rdi
movq %r15, %rsi
callq 0x30a0
jmp 0x695f
leaq -0x30(%rbp), %rdi
callq 0x777a
leaq 0x78(%rbx), %rdi
callq 0x3100
movq 0x10(%rbx), %rax
movq (%rax), %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x79b6
leaq -0x30(%rbp), %rdi
callq 0x6d08
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x6d08
movq %rbx, %rdi
callq 0x32e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zcount(double, double, bool, bool)
unsigned long zcount(double min, double max, bool minex = false, bool maxex = false) {
        RangeSpec range(min, max, minex, maxex);
        SkipListNode *zn;
        unsigned long rank;
        unsigned long count = 0;

        /* Find first element in range */
        zn = first_in_range(range);

        /* Use rank of first element, if any, to determine preliminary count */
        if (zn != NULL) {
            rank = get_rank(zn->mScore, zn->mKey);
            count = (mLength - (rank - 1));

            /* Find last element in range */
            zn = last_in_range(range);

            /* Use rank of last element, if any, to determine the actual count */
            if (zn != NULL) {
                rank = get_rank(zn->mScore, zn->mKey);
                count -= (mLength - rank);
            }
        }
        return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movb %sil, 0x10(%rax)
movb %dl, 0x11(%rax)
movq %rax, %rsi
callq 0x28fe
testq %rax, %rax
je 0x1bf6
movsd 0x8(%rax), %xmm0
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x29cc
movq 0x10(%rbx), %r14
subq %rax, %r14
incq %r14
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x2a2c
testq %rax, %rax
je 0x1bf9
movsd 0x8(%rax), %xmm0
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x29cc
addq %r14, %rax
subq 0x10(%rbx), %rax
movq %rax, %r14
jmp 0x1bf9
xorl %r14d, %r14d
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zrem(int)
void zrem(KeyType key) {
        DictTypeIterator it = mDict.find(key);
        if (it != mDict.end()) {
            double score = it->second;
            private_delete(score, key);
            mDict.erase(it);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %esi, %rax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %r8
xorl %edx, %edx
divq %r8
movq (%rcx,%rdx,8), %rbx
testq %rbx, %rbx
je 0x1c68
leaq 0x20(%rdi), %r15
leaq (%rcx,%rdx,8), %r14
cmpl %esi, (%rbx)
je 0x1c40
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1c31
jmp 0x1c68
cmpq (%rcx,%r8,8), %rbx
je 0x1c68
movsd 0x8(%rbx), %xmm0
callq 0x1f18
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b68
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::~SortedSet()
~SortedSet() 
    {
        SkipListNode *node = mHeader->mLevel[0].mForward, *next;
        delete mHeader;
        while (node) {
            next = node->mLevel[0].mForward;
            delete node;
            node = next;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x20(%r15), %rdi
movq (%rdi), %r14
callq 0x1150
movq %r15, %rdi
callq 0x1110
testq %r14, %r14
je 0x1cb9
movq 0x20(%r14), %rdi
movq (%rdi), %r15
callq 0x1150
movq %r14, %rdi
callq 0x1110
movq %r15, %r14
testq %r15, %r15
jne 0x1c9d
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1cd0
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zadd_generic(int, double, bool)
void zadd_generic(KeyType key, double score, bool incr) {
        DictTypeIterator it = mDict.find(key);
        if (it != mDict.end()) {
            double curscore = it->second;
            if (incr) {
                score += curscore;
            }
            if (score != curscore) {
                private_delete(curscore, key);
                private_insert(score, key);
                mDict[key] = score;
            }
        }
        else {
            private_insert(score, key);
            mDict[key] = score;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ecx
movapd %xmm0, %xmm1
movl %esi, %ebx
movq %rdi, %r14
movl %esi, -0x24(%rbp)
movslq %esi, %rax
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdi
xorl %edx, %edx
divq %rdi
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x1ee1
cmpl %ebx, (%rax)
je 0x1eb2
movq 0x10(%rax), %rax
jmp 0x1ea3
cmpq (%rsi,%rdi,8), %rax
je 0x1ee1
movsd 0x8(%rax), %xmm0
testb %cl, %cl
je 0x1ec5
addsd %xmm0, %xmm1
ucomisd %xmm0, %xmm1
jne 0x1ecd
jnp 0x1f0d
movq %r14, %rdi
movl %ebx, %esi
movsd %xmm1, -0x20(%rbp)
callq 0x1f18
movsd -0x20(%rbp), %xmm1
movsd %xmm1, -0x20(%rbp)
leaq 0x20(%r14), %r15
movq %r14, %rdi
movapd %xmm1, %xmm0
movl %ebx, %esi
callq 0x1fba
leaq -0x24(%rbp), %rsi
movq %r15, %rdi
callq 0x21e6
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq