LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x66b5
cmpq $0x0, 0x28(%rax)
js 0x66b5
movq %rax, %rdi
callq 0x32e0
jmp 0x669f
cmpq %rbx, %rax
sete %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29ce(%rip), %rbx      # 0x5fd0
leaq 0xc03(%rip), %rsi       # 0x420c
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2080
leaq 0xbe2(%rip), %rsi       # 0x4215
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
leaq 0xc00(%rip), %rsi       # 0x424a
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
leaq 0xbef(%rip), %rsi       # 0x4250
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
leaq 0xc08(%rip), %rsi       # 0x4280
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
leaq 0xc10(%rip), %rsi       # 0x429f
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2080
leaq 0xc10(%rip), %rsi       # 0x42be
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2080
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
leaq 0xc13(%rip), %rdi       # 0x42ec
callq 0x2140
testq %rax, %rax
je 0x3726
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x2946
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2a50
leaq 0x8(%rsp), %rdi
callq 0x2060
cmpb $0x0, 0x28(%rsp)
je 0x3733
leaq 0x28(%rsp), %rdi
callq 0x2d30
movl %eax, %ebx
jmp 0x375c
movq (%r14), %rdi
callq 0x35f4
pushq $-0x1
popq %rbx
jmp 0x3766
movq 0x28b6(%rip), %rdi      # 0x5ff0
leaq 0xbb9(%rip), %rsi       # 0x42fa
callq 0x20f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
pushq $-0x2
popq %rbx
leaq 0x28(%rsp), %rdi
callq 0x2cfa
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0x3789
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
jmp 0x3796
movq %rax, %rbx
jmp 0x3796
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2cfa
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_add.cc
// Function: main
int main() 
{

	string s1  = "hello, ", s2 = "world\n";
	string s3 = s1 + s2;   // s3 is hello, world\n
	cout << s1 << s2 << s3 << endl;

	s1 += s2;   // equivalent to s1 = s1 + s2
	cout << s1;
	
	string s4 = "hello", s5 = "world";  // no punctuation in s4 or s2
	string s6 = s4 + ", " + s5 + '\n';
	cout << s4 << s5 << "\n" << s6 << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0xdb5(%rip), %rsi       # 0x2004
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x1030
leaq 0xda9(%rip), %rsi       # 0x200c
leaq -0x28(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1030
leaq -0xc8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x1476
movq 0x2d4a(%rip), %rdi      # 0x3fd8
leaq -0x48(%rbp), %rsi
callq 0x1070
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x1070
leaq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1050
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10f0
movq 0x2d0a(%rip), %rdi      # 0x3fd8
leaq -0x48(%rbp), %rsi
callq 0x1070
leaq 0xd35(%rip), %rsi       # 0x2013
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x1030
leaq 0xd24(%rip), %rsi       # 0x2019
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x1030
leaq 0xcfd(%rip), %rdx       # 0x2009
leaq -0xe8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1503
leaq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x14da
leaq -0x88(%rbp), %rdi
leaq -0x108(%rbp), %rsi
pushq $0xa
popq %rdx
callq 0x14ae
leaq -0x108(%rbp), %rdi
callq 0x1040
leaq -0xe8(%rbp), %rdi
callq 0x1040
movq 0x2c6d(%rip), %rdi      # 0x3fd8
leaq -0xa8(%rbp), %rsi
callq 0x1070
leaq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x1070
leaq 0xc87(%rip), %rsi       # 0x2011
movq %rax, %rdi
callq 0x1080
leaq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1050
leaq -0x88(%rbp), %rdi
callq 0x1040
leaq -0x68(%rbp), %rdi
callq 0x1040
leaq -0xa8(%rbp), %rdi
callq 0x1040
leaq -0xc8(%rbp), %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1040
leaq -0x48(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x1040
jmp 0x1408
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
jmp 0x1431
movq %rax, %rbx
jmp 0x1436
movq %rax, %rbx
jmp 0x143f
jmp 0x144d
movq %rax, %rbx
jmp 0x145c
movq %rax, %rbx
jmp 0x1465
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x1040
leaq -0x68(%rbp), %rdi
callq 0x1040
leaq -0xa8(%rbp), %rdi
callq 0x1040
jmp 0x1450
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1040
leaq -0x48(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47f5
movsd %xmm0, 0x6294(%rip)     # 0x97d8
movq 0x5a95(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x3040
callq 0x4824
movq %rax, %rbx
leaq 0x176(%rip), %rdi       # 0x36df
movq %rax, %rsi
callq 0x4959
movq %rax, %r15
leaq 0x2a95(%rip), %rdi      # 0x6010
xorl %eax, %eax
callq 0x3749
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x485a
movl %eax, %r12d
callq 0x3050
movq %rax, %r14
movslq (%rax), %rax
leaq 0x5c8e(%rip), %rbp      # 0x9230
movq (%rbp,%rax,8), %rdx
leaq 0x2a7b(%rip), %rdi      # 0x6029
movl %r12d, %esi
xorl %eax, %eax
callq 0x3749
leaq 0x2a85(%rip), %r12      # 0x6044
movq %r12, %rdi
xorl %eax, %eax
callq 0x3749
movsd 0x2a37(%rip), %xmm0     # 0x6008
movq %rbx, %rdi
callq 0x485a
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x2a77(%rip), %r13      # 0x605f
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3749
movq %r12, %rdi
xorl %eax, %eax
callq 0x3749
movq %rbx, %rdi
movsd 0x29ff(%rip), %xmm0     # 0x6008
callq 0x485a
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
movq %r13, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3749
leaq 0x2a53(%rip), %rdi      # 0x607c
xorl %eax, %eax
callq 0x3749
pushq $0x1
popq %rdi
callq 0x3150
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x2a43(%rip), %rdi      # 0x608a
movl %eax, %esi
xorl %eax, %eax
callq 0x3749
movq %r15, %rdi
callq 0x49ca
leaq 0x1c3(%rip), %rdi       # 0x3822
movq %rbx, %rsi
callq 0x4959
movq %rax, %r15
leaq 0x2a29(%rip), %rdi      # 0x609a
xorl %eax, %eax
callq 0x3749
movq %r15, %rdi
callq 0x49b0
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x2a24(%rip), %rdi      # 0x60b3
movl %eax, %esi
xorl %eax, %eax
callq 0x3749
leaq 0x2a2f(%rip), %rdi      # 0x60ce
xorl %eax, %eax
callq 0x3749
movq %r15, %rdi
callq 0x49ca
movslq (%r14), %rcx
movq (%rbp,%rcx,8), %rdx
leaq 0x2a2a(%rip), %rdi      # 0x60e7
movl %eax, %esi
xorl %eax, %eax
callq 0x3749
movq %rbx, %rdi
callq 0x482f
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_O2/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 0x2a1e(%rip), %rdi      # 0x6108
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3749
leaq 0x2a25(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x3749
pushq $0x1
popq %rdi
callq 0x3150
leaq 0x2a19(%rip), %rdi      # 0x612a
xorl %eax, %eax
callq 0x3749
movq %rbx, %rdi
callq 0x4850
leaq 0x2a13(%rip), %rdi      # 0x613a
xorl %eax, %eax
callq 0x3749
movq %rbx, %rdi
callq 0x4855
leaq 0x2a0d(%rip), %rdi      # 0x614a
xorl %eax, %eax
callq 0x3749
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x37af
movapd %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x580a(%rip), %r12      # 0x8fe0
movq (%r12), %r15
callq 0x47f5
subsd 0x5ff1(%rip), %xmm0     # 0x97d8
leaq 0x2914(%rip), %rsi      # 0x6102
movq %r15, %rdi
movb $0x1, %al
callq 0x3310
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x32d0
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x33f0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
leaq 0x292a(%rip), %rdi      # 0x6157
xorl %eax, %eax
callq 0x3749
leaq 0x28e5(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x3749
pushq $0x1
popq %rdi
callq 0x3150
leaq 0x291e(%rip), %rdi      # 0x616f
xorl %eax, %eax
callq 0x3749
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x484f
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_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3360
cvtsi2sdq (%r15), %xmm1
cvtsi2sdq 0x8(%r15), %xmm0
mulsd 0x1ec5(%rip), %xmm0     # 0x6758
addsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x33a0
cvttsd2si %xmm0, %rax
leaq 0x10(%rsp), %r15
cvtsi2sd %rax, %xmm0
movq %rax, (%r15)
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x1eb4(%rip), %xmm1     # 0x6780
cvttsd2si %xmm1, %rax
movq %rax, 0x8(%r15)
leaq 0x30(%r14), %r12
movq %r12, %rdi
callq 0x3340
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3350
movl %eax, %ebp
callq 0x3050
movq %rax, %r14
movl %ebp, (%rax)
movq %r12, %rdi
callq 0x3160
cmpl (%r14), %ebx
sbbl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4997
xorl %eax, %eax
jmp 0x49a6
pushq $0x8
popq %rdi
callq 0x32c0
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq (%rdi), %rdi
movq %r14, %rsi
callq 0x31b0
movl %eax, %ebp
callq 0x3050
movl %ebp, (%rax)
movq %rbx, %rdi
callq 0x3270
movq (%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xc0, %rsp
movq 0x8(%rsi), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x1f(%rsp), %rdx
callq 0x2594
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2668
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq 0x4ad5(%rip), %rdi      # 0x6ff0
leaq 0x1afc(%rip), %rsi      # 0x401e
callq 0x2170
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x3686
leaq 0x1cc1(%rip), %rsi      # 0x41fc
movq %rax, %rdi
callq 0x2170
movq 0x4aa6(%rip), %rdi      # 0x6ff0
leaq 0x1ae2(%rip), %rsi      # 0x4033
callq 0x2170
leaq 0x40(%rsp), %rdi
callq 0x2a76
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x258c
movq %rax, %rbx
jmp 0x258c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2a76
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3150
movl 0x10(%rbp), %eax
movb %r13b, 0x20(%rbx)
movl %r12d, 0x24(%rbx)
movl %r15d, 0x28(%rbx)
movb %r14b, 0x2c(%rbx)
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3150
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x24(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movb 0x2c(%r14), %al
movb %al, 0x2c(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x78(%rdi)
jne 0x3dcc
movq 0xf8(%rdi), %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3250
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x5d86
movq (%rbx), %rax
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq -0x60(%rbp), %rdi
callq 0x5db0
leaq -0x30(%rbp), %rdi
callq 0x30f0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x93dd(%rip), %rbx      # 0xd1b0
movq %rbx, %rdi
callq 0x5a2a
movq 0x91f6(%rip), %rdi      # 0xcfd8
leaq 0x43f8(%rip), %rsi      # 0x81e1
callq 0x31e0
movq %rax, %rdi
callq 0x3120
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3180
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x5db0
jmp 0x3e17
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x118(%rdi), %r13
movq %r13, %rdi
callq 0x5afe
testb %al, %al
je 0x48a1
leaq -0xc8(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3250
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3150
leaq -0xc8(%rbp), %rdi
callq 0x30f0
movq 0x20(%r14), %r13
leaq -0xa8(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3250
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x3250
leaq -0x68(%rbp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4ba8
leaq -0x68(%rbp), %rdi
callq 0x30f0
leaq -0xa8(%rbp), %rdi
callq 0x30f0
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3250
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x3250
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x496a
leaq -0x48(%rbp), %rdi
callq 0x30f0
leaq -0x88(%rbp), %rdi
callq 0x30f0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4956
movq %rax, %r14
leaq -0x48(%rbp), %rdi
jmp 0x494f
jmp 0x4956
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x30f0
jmp 0x4959
movq %rax, %r14
movq %rbx, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x5b0c
movq 0x20(%r14), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3250
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4bf6
leaq -0x40(%rbp), %rdi
callq 0x30f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x8(%rdi), %r15
leaq -0x58(%rbp), %r12
movq %r15, %r13
movq -0x38(%rbp), %rbx
movq (%r13), %r13
cmpq %r15, %r13
je 0x4ac6
leaq 0x10(%r13), %rdi
movq -0x30(%rbp), %rsi
callq 0x5adb
testb %al, %al
je 0x4a76
movq %r15, %rdi
movq %r13, %rsi
callq 0x5b44
movq %rax, %r13
movq 0x20(%rbx), %r14
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x3250
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4e5c
movq %r12, %rdi
callq 0x30f0
jmp 0x4a76
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x20(%rbp), %rdi
movq $0x5, (%rdi)
callq 0x574a
addq $0x38, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x708c
testq %rbx, %rbx
je 0x4b8a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xd0(%rdi), %r12
movq %r12, %rdi
callq 0x5a2a
addq $0x38, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7258
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3150
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
addq $0xf8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5a2a
leaq 0x70(%r12), %r13
leaq -0xd8(%rbp), %r14
movq %r14, %rdi
movq %rbx, -0x40(%rbp)
movq %rbx, %rsi
callq 0x3250
movq %r15, -0x30(%rbp)
movq %r15, 0x20(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x788e
leaq -0xd8(%rbp), %rdi
callq 0x30f0
movq -0x38(%rbp), %rdi
callq 0x3180
leaq 0xd0(%r12), %rbx
movq %rbx, %rdi
callq 0x5a2a
addq $0x38, %r12
movq %r12, %rdi
movq -0x40(%rbp), %rsi
callq 0x7d1c
testq %rax, %rax
je 0x4cf6
movq %rax, %r15
movq -0x30(%rbp), %rax
movq 0x30(%rax), %r14
leaq 0x8(%r15), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3250
addq $0x28, %r15
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x3250
leaq -0xd8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5b5c
movq (%r14), %rax
leaq -0xd8(%rbp), %rsi
movq %r14, %rdi
callq *(%rax)
leaq -0xd8(%rbp), %rdi
callq 0x5bba
leaq -0x60(%rbp), %rdi
callq 0x30f0
leaq -0x80(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3180
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x5bba
jmp 0x4d24
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x30f0
jmp 0x4d32
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x4d42
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x40(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
addq $0xf8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x5a2a
addq $0x70, %rbx
movq %rbx, %rdi
movq %r14, -0x38(%rbp)
movq %r14, %rsi
callq 0x7628
movq %rax, %r12
movq %rdx, -0x48(%rbp)
leaq -0x88(%rbp), %r14
leaq -0x68(%rbp), %rbx
leaq -0xe0(%rbp), %r15
cmpq -0x48(%rbp), %r12
je 0x4e0b
movq 0x28(%r12), %rax
movq 0x30(%rax), %r13
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x3250
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x3250
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x5b5c
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, %rdi
callq 0x5bba
movq %rbx, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x30f0
movq (%r12), %r12
jmp 0x4daa
movq -0x30(%rbp), %rdi
callq 0x3180
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4e48
movq %rax, %rbx
jmp 0x4e3f
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x5bba
leaq -0x68(%rbp), %rdi
callq 0x30f0
leaq -0x88(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5a2a
addq $0x70, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x7628
movq 0x28(%rax), %rcx
cmpq %rdx, %rax
je 0x4ea1
cmpq %r15, %rcx
je 0x4ea6
movq (%rax), %rax
jmp 0x4e8e
cmpq %r15, %rcx
jne 0x4eb1
movq %r14, %rdi
movq %rax, %rsi
callq 0x7778
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x10(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x4ee9
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x4ed0
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4ed0
leaq 0x70(%rbx), %rdi
callq 0x5ef0
leaq 0x38(%rbx), %rdi
callq 0x5fb4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6098
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x20(%rbp), %r15
movq %rsi, (%r15)
leaq 0xa8(%rdi), %rbx
movq %rbx, %rdi
callq 0x5a2a
movq %r14, %rdi
movq %r15, %rsi
callq 0x6cb6
testq %rax, %rax
je 0x4f56
movq %rax, %r15
cmpq $0x0, 0x10(%rax)
je 0x4f56
movq %rbx, %rdi
callq 0x3180
movq 0x10(%r15), %r15
jmp 0x4f8e
movl $0x178, %edi            # imm = 0x178
callq 0x31f0
movq %rax, %r15
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x3ecc
movq -0x20(%rbp), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq %r14, %rdi
callq 0x6d40
movq %rbx, %rdi
callq 0x3180
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
leaq 0x58(%rdi), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
leaq -0xd8(%rbp), %r12
leaq -0x80(%rbp), %r13
movq %rdi, -0x38(%rbp)
cmpl 0x88(%r15), %eax
jae 0x5415
movl %eax, -0x2c(%rbp)
movq $0x1, -0xd8(%rbp)
movq %r12, %rdi
callq 0x574a
movq 0xf8(%r15), %r14
movq %r13, %rdi
movq -0x40(%rbp), %rsi
callq 0x3250
callq 0x3060
movl 0x80(%r15), %ecx
cltd
idivl %ecx
movl %edx, %esi
movl %ecx, %eax
cltd
pushq $-0x2
popq %rcx
idivl %ecx
addl %eax, %esi
addl 0x7c(%r15), %esi
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x5dc8
movzbl 0x84(%r15), %ecx
movq %r12, %rdi
movq %r13, %r15
movq %r13, %rsi
movq %rbx, %rdx
callq 0x5b5c
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %r12, %rdi
callq 0x5bba
movq %rbx, %rdi
callq 0x30f0
movq %r15, %r13
movq %r15, %rdi
callq 0x30f0
movl -0x2c(%rbp), %eax
incl %eax
movq -0x38(%rbp), %r15
jmp 0x5366
movq 0xf8(%r15), %rdi
leaq 0x7865(%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
leaq -0xd8(%rbp), %rdi
callq 0x5bba
jmp 0x5460
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x30f0
jmp 0x546e
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5517
cmpl $0x1, %eax
jne 0x5523
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5568
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5614
leaq 0x7c86(%rip), %r14      # 0xd1b0
movq %r14, %rdi
callq 0x5a2a
movq 0x7a9f(%rip), %rdi      # 0xcfd8
leaq 0x2cc0(%rip), %rsi      # 0x8200
callq 0x31e0
addq $0x10, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31b0
movq %rax, %rdi
callq 0x3120
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3180
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rsi), %eax
testl %eax, %eax
je 0x5592
cmpl $0x1, %eax
jne 0x560a
leaq 0x2cc2(%rip), %r14      # 0x824f
xorl %r12d, %r12d
jmp 0x559c
movb $0x1, %r12b
leaq 0x2cac(%rip), %r14      # 0x8248
leaq 0x7c0d(%rip), %r15      # 0xd1b0
movq %r15, %rdi
callq 0x5a2a
movq 0x7a26(%rip), %rdi      # 0xcfd8
leaq 0x2c6d(%rip), %rsi      # 0x8226
callq 0x31e0
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x31b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31e0
movq %rax, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3180
movb %r12b, 0x90(%rbx)
movb $0x1, 0xf0(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3130
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7b82(%rip), %rdi      # 0xd1b0
callq 0x5a2a
movq 0x799e(%rip), %rdi      # 0xcfd8
leaq 0x2c18(%rip), %rsi      # 0x8259
callq 0x31e0
addq $0x10, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x31b0
leaq 0x2abc(%rip), %rsi      # 0x8118
movq %rax, %rdi
callq 0x31e0
leaq 0x2aaf(%rip), %rsi      # 0x811a
movq %rax, %rdi
callq 0x31e0
movq %rax, %r14
leaq 0x10(%rbx), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x3250
movq %r14, %rdi
movq %r15, %rsi
callq 0x31b0
leaq 0x2aaf(%rip), %rsi      # 0x8147
movq %rax, %rdi
callq 0x31e0
movq %rax, %r14
addq $0x30, %rbx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x3250
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x31b0
movq %rax, %rdi
callq 0x3120
leaq -0x38(%rbp), %rdi
callq 0x30f0
leaq -0x58(%rbp), %rdi
callq 0x30f0
leaq 0x7ad0(%rip), %rdi      # 0xd1b0
callq 0x3180
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5700
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30f0
jmp 0x5703
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x5d4c
leaq 0x78(%rbx), %r12
movq %rbx, %rdi
callq 0x677c
cmpq $0x64, %rax
jne 0x5938
movq %r12, %rdi
movq %r15, %rsi
callq 0x3090
jmp 0x591d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67ce
leaq -0x30(%rbp), %rdi
callq 0x674c
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x3130
leaq -0x30(%rbp), %rdi
callq 0x5d6c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5d6c
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x5d4c
leaq 0xa8(%rbx), %r12
movq %rbx, %rdi
callq 0x677c
testq %rax, %rax
jne 0x59cc
movq %r12, %rdi
movq %r15, %rsi
callq 0x3090
jmp 0x59b2
leaq -0x30(%rbp), %rdi
callq 0x674c
leaq 0x78(%rbx), %rdi
callq 0x3130
movq 0x10(%rbx), %rax
movq (%rax), %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x69c8
leaq -0x30(%rbp), %rdi
callq 0x5d6c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5d6c
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x273c
testq %rax, %rax
je 0x1882
movsd 0x8(%rax), %xmm0
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x27fe
movq 0x10(%rbx), %r14
subq %rax, %r14
incq %r14
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x284e
testq %rax, %rax
je 0x1885
movsd 0x8(%rax), %xmm0
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0x27fe
addq %r14, %rax
subq 0x10(%rbx), %rax
movq %rax, %r14
jmp 0x1885
xorl %r14d, %r14d
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x24(%rbp), %rax
movl %esi, (%rax)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1da0
movq %rax, %r12
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
cmpq (%rax,%rcx,8), %r12
je 0x18ed
movq %rdx, %r15
movsd 0x8(%r12), %xmm0
movl -0x24(%rbp), %esi
movq %r14, %rdi
callq 0x1dee
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2980
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zscore(int, double&)
bool zscore(KeyType key, double &score) {
        DictTypeConstIterator it = mDict.find(key);
        if (it != mDict.end()) {
            score = it->second;
            return true;
        }
        else {
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x14(%rbp), %rax
movl %esi, (%rax)
addq $0x20, %rdi
movq %rax, %rsi
callq 0x1da0
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
je 0x1947
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rbx)
cmpq %rcx, %rax
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zremrangebyrank(long, long)
void zremrangebyrank(long start, long end) {
        long llen = length();
        if (start < 0) start = llen + start;
        if (end < 0) end = llen + end;
        if (start < 0) start = 0;
        /* Invariant: start >= 0, so this test will be true when end < 0.
         * The range is empty when start > end or start >= length. */
        if (start > end || start >= llen) {
            return;
        }
        if (end >= llen) end = llen - 1;
        /* Correct for 1-based rank. */
        private_delete_range_by_rank(start+1, end+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rax
movq 0x10(%rdi), %rcx
movq %rsi, %r8
sarq $0x3f, %r8
andq %rcx, %r8
addq %rsi, %r8
sarq $0x3f, %rdx
andq %rcx, %rdx
addq %rax, %rdx
xorl %esi, %esi
testq %r8, %r8
cmovgq %r8, %rsi
cmpq %rdx, %rsi
setg %al
cmpq %rcx, %rsi
setge %r8b
orb %al, %r8b
jne 0x19ee
leal -0x1(%rcx), %eax
incl %esi
cmpq %rcx, %rdx
cmovael %eax, %edx
incl %edx
popq %rbp
jmp 0x2bc4
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq (%rax), %r14
movq %r15, %rdi
callq 0x1cf4
movq %r15, %rdi
callq 0x10f0
testq %r14, %r14
je 0x1a38
movq 0x20(%r14), %rax
movq (%rax), %r15
movq %r14, %rdi
callq 0x1cf4
movq %r14, %rdi
callq 0x10f0
movq %r15, %r14
jmp 0x1a17
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ab0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movsd %xmm0, -0x28(%rbp)
movq %rdi, %r14
leaq -0x1c(%rbp), %rax
movl %esi, (%rax)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1da0
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x1d70
movsd -0x28(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
testb %r15b, %r15b
je 0x1d58
addsd %xmm0, %xmm1
ucomisd %xmm0, %xmm1
jne 0x1d60
jnp 0x1d95
movl -0x1c(%rbp), %esi
movq %r14, %rdi
movsd %xmm1, -0x28(%rbp)
callq 0x1dee
movl -0x1c(%rbp), %esi
movq %r14, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x1e82
leaq -0x1c(%rbp), %rsi
movq %rbx, %rdi
callq 0x204a
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq