LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpdb.cpp
// Function: SSDPDB::DeleteDevicesByUuid(unsigned char*, unsigned int)
int SSDPDB::DeleteDevicesByUuid(u8* uuid, u32 uuidlen){
    int tel = 0;
    SSDPDBDevice* thisdevice = NULL;
    int updated = 0;

    Lock();
    unsigned int i=0;
    while(i<mDevices.size()){
        thisdevice = mDevices[i];
        if( (thisdevice->uuid.length() == uuidlen &&  memcmp(thisdevice->uuid.c_str(), uuid, uuidlen) == 0) ){
            mDevices.erase(mDevices.begin()+i);
            delete(thisdevice);
            updated++;
        }else{
            i++;
        }
    }
    Unlock();

    if(updated > 0){
        DeviceUpdate(NULL);
    }

    return tel;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
addq $0x38, %rdi
movq %rdi, 0x18(%rsp)
callq 0x3320
movl %ebp, %r12d
movl $0x0, 0xc(%rsp)
xorl %r14d, %r14d
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbp
movq 0x8(%rbx), %rbx
subq %rbp, %rbx
sarq $0x3, %rbx
movl %r14d, %r15d
cmpq %r15, %rbx
jbe 0x4ddf
movq (%rbp,%r15,8), %r13
cmpq %r12, 0x10(%r13)
jne 0x4da7
movq 0x8(%r13), %rdi
movq 0x20(%rsp), %rsi
movq %r12, %rdx
callq 0x3290
testl %eax, %eax
je 0x4dac
incl %r14d
jmp 0x4d7f
leaq (,%r15,8), %rsi
addq %rbp, %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x50e4
movq %r13, %rdi
callq 0x56c2
movl $0x150, %esi            # imm = 0x150
movq %r13, %rdi
callq 0x3280
incl 0xc(%rsp)
jmp 0x4d71
movq 0x18(%rsp), %rdi
callq 0x31b0
cmpl $0x0, 0xc(%rsp)
je 0x4dfa
movq 0x10(%rsp), %rdi
callq 0x4cfa
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpdb.cpp
// Function: SSDPDB::RemoveAllDevices()
void SSDPDB::RemoveAllDevices() {
    printf("SSDPDB::RemoveAllDevices\n");
    Lock();
    mDevices.clear();
    Unlock();

    SSDPDBMsg msg;
    std::vector<SSDPDBObserver*>::iterator it;
    msg.type = SSDPDBMsg_DeviceUpdate;
    for(it=mObservers.begin();it<mObservers.end();it++){
        ((SSDPDBObserver*)*it)->SSDPDBMessage(&msg);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x35d9(%rip), %rdi      # 0x845a
callq 0x3370
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x3320
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4e9f
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x31b0
leaq 0xc(%rsp), %r14
movl $0x1, (%r14)
movq 0x18(%rbx), %r15
cmpq 0x20(%rbx), %r15
jae 0x4ece
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x4eb7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpdb.cpp
// Function: SSDPDB::ServiceUpdate(SSDPDBDevice*)
void SSDPDB::ServiceUpdate(SSDPDBDevice* service){
    SSDPDBMsg msg;
    std::vector<SSDPDBObserver*>::iterator it;
    msg.type = SSDPDBMsg_ServiceUpdate;
    for(it=mObservers.begin();it<mObservers.end();it++){
        ((SSDPDBObserver*)*it)->SSDPDBMessage(&msg);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x2, (%r14)
movq 0x18(%rdi), %r15
cmpq 0x20(%rbx), %r15
jae 0x4f63
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x4f4c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpdb.cpp
// Function: SSDPDB::UpdateCacheControl(unsigned char*, unsigned int, int)
int SSDPDB::UpdateCacheControl(u8* uuid, u32 uuidlen, int cachecontrol){
    int tel = 0;
    SSDPDBDevice* thisdevice = NULL;

    Lock();
    vector<SSDPDBDevice*>::const_iterator it;
    it=mDevices.begin();
    while(it < mDevices.end()){
        thisdevice = *it;
        if( (thisdevice->uuid.length() == uuidlen &&  memcmp(thisdevice->uuid.c_str(), uuid, uuidlen) == 0) ){
            thisdevice->cachecontrol = cachecontrol;
            thisdevice->lastupdate = systimeinseconds;
            tel++;
        }
        it++;
    }
    Unlock();

    return tel;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
addq $0x38, %rdi
movq %rdi, 0x10(%rsp)
callq 0x3320
movq (%r12), %r14
movl %ebp, %ebp
xorl %r13d, %r13d
cmpq 0x8(%r12), %r14
jae 0x4fe3
movq (%r14), %rbx
cmpq %rbp, 0x10(%rbx)
jne 0x4fdd
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3290
testl %eax, %eax
jne 0x4fdd
movl 0xc(%rsp), %eax
movl %eax, 0x140(%rbx)
xorl %edi, %edi
callq 0x3220
movq %rax, 0x148(%rbx)
incl %r13d
addq $0x8, %r14
jmp 0x4f9f
movq 0x10(%rsp), %rdi
callq 0x31b0
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpdb.cpp
// Function: SSDPDB::CacheControlLoop()
int SSDPDB::CacheControlLoop(){
    mRun = 1;
    SSDPDBDevice* thisdevice = NULL;
    vector<SSDPDBDevice*>::iterator it;
    time_t nows;
    u8 updated;
    while(mRun){
        sleep(CACHE_CONTROL_TIMEOUT);

        Lock();
        updated = 0;
        nows = time(NULL);
        unsigned int i=0;
        while(i<mDevices.size()){
            thisdevice = mDevices[i];
            if((time_t)(thisdevice->lastupdate + thisdevice->cachecontrol) <= nows){
                mDevices.erase(mDevices.begin()+i);
                delete(thisdevice);
                updated++;
            }else{
                i++;
            }
        }
        Unlock();

        if(updated > 0){
            DeviceUpdate(NULL);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x68(%rdi)
leaq 0x38(%rdi), %r14
movb $0x1, %al
testb %al, %al
je 0x50b4
pushq $0x1e
popq %rdi
callq 0x3190
movq %r14, %rdi
callq 0x3320
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x3220
movq %rax, %r15
xorl %ebp, %ebp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movl %ebp, %edx
cmpq %rdx, %rcx
jbe 0x5097
movq (%rax,%rdx,8), %r12
movl 0x140(%r12), %esi
addq 0x148(%r12), %rsi
cmpq %r15, %rsi
jle 0x5071
incl %ebp
jmp 0x504d
leaq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x50e4
movq %r12, %rdi
callq 0x56c2
movl $0x150, %esi            # imm = 0x150
movq %r12, %rdi
callq 0x3280
incb %r13b
jmp 0x503f
movq %r14, %rdi
callq 0x31b0
testb %r13b, %r13b
je 0x50ac
movq %rbx, %rdi
callq 0x4cfa
movb 0x68(%rbx), %al
jmp 0x5018
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpdbdevice.cpp
// Function: SSDPDBDevice::SSDPDBDevice()
SSDPDBDevice::SSDPDBDevice(){
    isroot=0;
    isservice=0;
    isdevice=0;  
    uuid = "";
    urn="";
    type="";
    version="";
    host="";
    usn="";
    lastupdate=0;
    cachecontrol=0;
    ip=0;
    port=0;
    memset(&parsedusn, 0, sizeof(ssdpuuid));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
addq $0x8, %rdi
leaq 0x28(%r14), %r15
movb %al, 0x58(%r14)
leaq 0xc8(%r14), %rcx
movq %rcx, 0xb8(%r14)
andq $0x0, 0xc0(%r14)
leaq 0x48(%r14), %r12
leaq 0xb8(%r14), %r13
movb %al, 0xc8(%r14)
leaq 0xe8(%r14), %rcx
movq %rcx, 0xd8(%r14)
andq $0x0, 0xe0(%r14)
leaq 0xd8(%r14), %rbp
movb %al, 0xe8(%r14)
leaq 0xf8(%r14), %rbx
leaq 0x108(%r14), %rcx
movq %rcx, 0xf8(%r14)
andq $0x0, 0x100(%r14)
movb %al, 0x108(%r14)
leaq 0x118(%r14), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x128(%r14), %rcx
movq %rcx, 0x118(%r14)
andq $0x0, 0x120(%r14)
movb %al, 0x128(%r14)
andw $0x0, 0x1(%r14)
movb %al, (%r14)
leaq 0x2d90(%rip), %rsi      # 0x8361
movq %rdi, 0x10(%rsp)
callq 0x3410
leaq 0x2d7f(%rip), %rsi      # 0x8361
movq %r15, %rdi
callq 0x3410
leaq 0x2d70(%rip), %rsi      # 0x8361
movq %r13, %rdi
callq 0x3410
leaq 0x2d61(%rip), %rsi      # 0x8361
movq %rbp, %rdi
callq 0x3410
leaq 0x2d52(%rip), %rsi      # 0x8361
movq %rbx, %rdi
callq 0x3410
leaq 0x2d43(%rip), %rsi      # 0x8361
movq %r12, %rdi
callq 0x3410
andq $0x0, 0x148(%r14)
andl $0x0, 0x140(%r14)
andl $0x0, 0x138(%r14)
andw $0x0, 0x13c(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x98(%r14)
movups %xmm0, 0xa8(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x3448
movq %rbp, %rdi
callq 0x3448
movq %r13, %rdi
callq 0x3448
movq %r12, %rdi
callq 0x3448
movq %r15, %rdi
callq 0x3448
movq 0x10(%rsp), %rdi
callq 0x3448
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpmessage.cpp
// Function: SSDPMessage::~SSDPMessage()
SSDPMessage::~SSDPMessage(){
    std::vector<SSDP_HTTP_HEADER*>::iterator it;
    for(it=mHeaderSignature.begin();it<mHeaderSignature.end();it++){
        free(*it);
    }
    mHeaderSignature.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x726b(%rip), %rax      # 0xc9b0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %r15
movq 0x10(%rbx), %rax
cmpq %rax, %r15
jae 0x5767
movq (%r15), %rdi
callq 0x32b0
addq $0x8, %r15
jmp 0x5750
movq (%r14), %rcx
cmpq %rcx, %rax
je 0x5773
movq %rcx, 0x10(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x594c
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpmessage.cpp
// Function: SSDPMessage::AddSignatureHeader(char*, char*)
int SSDPMessage::AddSignatureHeader(char* fieldname, char* fieldvalue){
    SSDP_HTTP_HEADER *thisHeader = (SSDP_HTTP_HEADER*)malloc(sizeof(SSDP_HTTP_HEADER));
    thisHeader->fieldname = (u8*)fieldname;
    thisHeader->fieldnamelen = (unsigned int)strlen(fieldname);
    thisHeader->fieldvalue = (u8*)fieldvalue;
    thisHeader->fieldvaluelen = (unsigned int)strlen(fieldvalue);
    mHeaderSignature.push_back(thisHeader);
    return (int)mHeaderSignature.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x32f0
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %r15, (%rax)
movq %r15, %rdi
callq 0x30e0
movl %eax, 0x8(%r12)
movq %r14, 0x10(%r12)
movq %r14, %rdi
callq 0x30e0
movl %eax, 0x18(%r12)
leaq 0x8(%rbx), %rdi
movq %r13, %rsi
callq 0x592e
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpnotifyalive.cpp
// Function: SSDPNotifyAlive::SSDPNotifyAlive()
SSDPNotifyAlive::SSDPNotifyAlive(){
    AddSignatureHeader((char*)"HOST", (char*)"");
    AddSignatureHeader((char*)"CACHE-CONTROL", (char*)"");
    AddSignatureHeader((char*)"LOCATION", (char*)"");
    AddSignatureHeader((char*)"NT", (char*)"");
    AddSignatureHeader((char*)"NTS", (char*)"ssdp:alive");
    AddSignatureHeader((char*)"SERVER", (char*)"");
    AddSignatureHeader((char*)"USN", (char*)"");
    /* Disabled because some devices don't send it
    AddSignatureHeader("BOOTID.UPNP.ORG", "");
    AddSignatureHeader("CONFIGID.UPNP.ORG", "");
    */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5ee8
leaq 0x6fe9(%rip), %rax      # 0xcaf8
movq %rax, (%rbx)
leaq 0x298d(%rip), %rsi      # 0x84a6
leaq 0x2841(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x297c(%rip), %rsi      # 0x84ab
leaq 0x282b(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2974(%rip), %rsi      # 0x84b9
leaq 0x2815(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2967(%rip), %rsi      # 0x84c2
leaq 0x27ff(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2954(%rip), %rsi      # 0x84c5
leaq 0x2951(%rip), %rdx      # 0x84c9
movq %rbx, %rdi
callq 0x5862
leaq 0x294d(%rip), %rsi      # 0x84d4
leaq 0x27d3(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x293e(%rip), %rsi      # 0x84db
leaq 0x27bd(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5736
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpnotifybye.cpp
// Function: SSDPNotifyBye::SSDPNotifyBye()
SSDPNotifyBye::SSDPNotifyBye(){
    AddSignatureHeader((char*)"HOST", (char*)"");
    AddSignatureHeader((char*)"NT", (char*)"");
    AddSignatureHeader((char*)"NTS", (char*)"ssdp:byebye");
    AddSignatureHeader((char*)"USN", (char*)"");
    /*
    AddSignatureHeader("BOOTID.UPNP.ORG", "");
    AddSignatureHeader("CONFIGID.UPNP.ORG", "");
    */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5ee8
leaq 0x6c3d(%rip), %rax      # 0xcb68
movq %rax, (%rbx)
leaq 0x2571(%rip), %rsi      # 0x84a6
leaq 0x2425(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2577(%rip), %rsi      # 0x84c2
leaq 0x240f(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2564(%rip), %rsi      # 0x84c5
leaq 0x25e6(%rip), %rdx      # 0x854e
movq %rbx, %rdi
callq 0x5862
leaq 0x2564(%rip), %rsi      # 0x84db
leaq 0x23e3(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5736
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpnotifybye.cpp
// Function: SSDPNotifyBye::Process(sockaddr*, std::vector<SSDP_HTTP_HEADER*, std::allocator<SSDP_HTTP_HEADER*>>)
int SSDPNotifyBye::Process(struct sockaddr* sender, std::vector<SSDP_HTTP_HEADER*> msgheaders){
    int ret = 0;
    u8* usn;
    int usnlen;
    ssdpuuid uuid;

    //Get the Device USN (Unique Service Name)
    ret=GetHeaderValueFromCollection(msgheaders, (u8*)"USN", 3, &usn, &usnlen);
    if(ret != 0 || usnlen<=0){
        ret = -1;
        goto EXIT;
    }

    ret = ParseUSN(usn, usnlen, &uuid);
    if(ret < 0){
        goto EXIT;//Unknown format
    }

    //Delete the UUID
    //Specs : If a control point has received at least one ssdp:byebye message of a root device, any of its embedded devices or any of its
    //        services then the control point can assume that all are no longer available.
    mDB->DeleteDevicesByUuid(uuid.uuid, uuid.uuidlen);



EXIT:
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x58e0
leaq 0x2512(%rip), %rsi      # 0x84db
pushq $0x3
popq %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %r14, %rdi
callq 0x6cfc
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0x594c
testl %ebp, %ebp
setne %al
movl 0xc(%rsp), %esi
testl %esi, %esi
setle %cl
orb %al, %cl
je 0x6001
pushq $-0x1
popq %rbp
jmp 0x6028
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x6d76
movl %eax, %ebp
testl %eax, %eax
js 0x6028
movq 0x20(%rbx), %rdi
movq 0x30(%rsp), %rsi
movl 0x38(%rsp), %edx
callq 0x4d38
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x594c
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpnotifyupdate.cpp
// Function: SSDPNotifyUpdate::SSDPNotifyUpdate()
SSDPNotifyUpdate::SSDPNotifyUpdate(){
    AddSignatureHeader((char*)"HOST", (char*)"");
    AddSignatureHeader((char*)"LOCATION", (char*)"");
    AddSignatureHeader((char*)"NT", (char*)"");
    AddSignatureHeader((char*)"NTS", (char*)"ssdp:update");
    AddSignatureHeader((char*)"USN", (char*)"");
    /*
    AddSignatureHeader("BOOTID.UPNP.ORG", "");
    AddSignatureHeader("CONFIGID.UPNP.ORG", "");
    AddSignatureHeader("NEXTBOOTID.UPNP.ORG", "");
    */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5ee8
leaq 0x6b61(%rip), %rax      # 0xcbd8
movq %rax, (%rbx)
leaq 0x2425(%rip), %rsi      # 0x84a6
leaq 0x22d9(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2422(%rip), %rsi      # 0x84b9
leaq 0x22c3(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2415(%rip), %rsi      # 0x84c2
leaq 0x22ad(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x2402(%rip), %rsi      # 0x84c5
leaq 0x24a0(%rip), %rdx      # 0x856a
movq %rbx, %rdi
callq 0x5862
leaq 0x2402(%rip), %rsi      # 0x84db
leaq 0x2281(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5736
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpparser.cpp
// Function: SSDPParser::SSDPParser(SSDPDB*)
SSDPParser::SSDPParser(SSDPDB* db):mType(SSDP_TYPE_UNKNOWN){
    mDB = db;

    /*
     * Register all implemented message types
     */
    SSDPMessage* msg;
    msg = new SSDPNotifyAlive();
    msg->SetDB(mDB);
    mMessages.push_back(msg);

    msg = new SSDPNotifyBye();
    msg->SetDB(mDB);
    mMessages.push_back(msg);

    msg = new SSDPNotifyUpdate();
    msg->SetDB(mDB);
    mMessages.push_back(msg);

    msg = new SSDPSearchReq();
    msg->SetDB(mDB);
    mMessages.push_back(msg);

    msg = new SSDPSearchResp();
    msg->SetDB(mDB);
    mMessages.push_back(msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, (%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rsi, 0x38(%rdi)
pushq $0x28
popq %rdi
callq 0x3260
movq %rax, %r12
movq %rax, %rdi
callq 0x5afc
movq %r12, (%rsp)
movq 0x38(%rbx), %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6620
pushq $0x28
popq %rdi
callq 0x3260
movq %rax, %r12
movq %rax, %rdi
callq 0x5f18
movq %r12, (%rsp)
movq 0x38(%rbx), %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6620
pushq $0x28
popq %rdi
callq 0x3260
movq %rax, %r12
movq %rax, %rdi
callq 0x6064
movq %r12, (%rsp)
movq 0x38(%rbx), %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6620
pushq $0x28
popq %rdi
callq 0x3260
movq %rax, %r12
movq %rax, %rdi
callq 0x67b8
movq %r12, (%rsp)
movq 0x38(%rbx), %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6620
pushq $0x28
popq %rdi
callq 0x3260
movq %rax, %r12
movq %rax, %rdi
callq 0x6864
movq %r12, (%rsp)
movq 0x38(%rbx), %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6620
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6249
jmp 0x6249
jmp 0x6249
jmp 0x6249
movq %rax, %r15
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0x3280
jmp 0x625c
movq %rax, %r15
addq $0x8, %rbx
movq %r14, %rdi
callq 0x663e
movq %rbx, %rdi
callq 0x594c
movq %r15, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpparser.cpp
// Function: SSDPParser::~SSDPParser()
SSDPParser::~SSDPParser(){
    std::vector<SSDP_HTTP_HEADER*>::iterator it;
    for(it=mHeaders.begin();it<mHeaders.end();it++){
        free(*it);
    }
    mHeaders.clear();

    std::vector<SSDPMessage*>::iterator itmsg;
    for(itmsg=mMessages.begin();itmsg<mMessages.end();itmsg++){
        delete(*itmsg);
    }
    mMessages.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %r15
movq 0x10(%r14), %rax
cmpq %rax, %r15
jae 0x62a2
movq (%r15), %rdi
callq 0x32b0
addq $0x8, %r15
jmp 0x628b
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0x62ae
movq %rcx, 0x10(%r14)
leaq 0x20(%r14), %r15
movq 0x20(%r14), %r12
movq 0x28(%r14), %rax
cmpq %rax, %r12
jae 0x62d4
movq (%r12), %rdi
testq %rdi, %rdi
je 0x62ce
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r12
jmp 0x62b6
movq (%r15), %rcx
cmpq %rcx, %rax
je 0x62e0
movq %rcx, 0x28(%r14)
movq %r15, %rdi
callq 0x663e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x594c
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpparser.cpp
// Function: SSDPParser::ReInit()
int SSDPParser::ReInit(){
    //Clear all headers of previous session (if any)
    if(mHeaders.size() > 0){
        std::vector<SSDP_HTTP_HEADER*>::iterator it;
        for(it=mHeaders.begin();it<mHeaders.end();it++){
            free(*it);
        }
        mHeaders.clear();
    }


    //ReInit all messages
    if(mMessages.size() > 0){
        std::vector<SSDPMessage*>::const_iterator itmsg;
        for(itmsg=mMessages.begin();itmsg<mMessages.end();itmsg++){
            ((SSDPMessage*)*itmsg)->ReInit();
        }
    }

    //Clear all members
    mType = SSDP_TYPE_UNKNOWN;


    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rax
cmpq %r14, %rax
jne 0x6322
jmp 0x6334
movq (%r14), %rdi
callq 0x32b0
addq $0x8, %r14
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jb 0x6312
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x6334
movq %rcx, 0x10(%rbx)
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rax
cmpq %r14, %rax
je 0x6359
cmpq %rax, %r14
jae 0x6359
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x8, %r14
movq 0x28(%rbx), %rax
jmp 0x6341
andl $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpparser.cpp
// Function: SSDPParser::ReadLine(unsigned char*, unsigned int, unsigned char**, unsigned int*)
int SSDPParser::ReadLine(u8 *buf, u32 len, u8 **restbuf, u32 *restlen){
    int ret = 0;

    // If len is <2 it's not possible that we're going to find \r\n
    if (len < 2) {
        return -1;
    }

    //Search the \r\n
    u8 *pos = (u8 *)strnstr((char*)buf, "\r\n", len);
    if( !pos )
        return -1;
    // \r\n or eof
    *restlen = len - (u32)(pos + 2 - buf);

    if( *restlen == 0 ){
        ret = -1;//eof
    }else{
        *restbuf = pos + 2;
        ret = len - *restlen - 2;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $-0x1
popq %rbx
cmpl $0x2, %edx
jb 0x65ba
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movl %edx, %edx
leaq 0x1dcb(%rip), %rsi      # 0x835f
movq %r14, %rdi
callq 0x65c9
testq %rax, %rax
je 0x65ba
addq $0x2, %rax
subl %eax, %r14d
addl %r14d, %ebp
movl %ebp, (%r12)
je 0x65ba
movq %rax, (%r15)
pushq $-0x2
popq %rbx
subl %r14d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpparser.cpp
// Function: strnstr(char*, char const*, unsigned long)
char *strnstr(char *str, const char *substr, size_t n)
{
    char *p = str, *pEnd = str+n;
    size_t substr_len = strlen(substr);

    if(0 == substr_len)
        return str; // the empty string is contained everywhere.

    pEnd -= (substr_len - 1);
    for(;p < pEnd; ++p)
    {
        if(0 == strncmp(p, substr, substr_len))
            return p;
    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x30e0
testq %rax, %rax
je 0x6611
movq %rax, %r12
addq %rbx, %r14
subq %rax, %r14
incq %r14
cmpq %r14, %rbx
jae 0x660f
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x30f0
testl %eax, %eax
je 0x6611
incq %rbx
jmp 0x65f3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdpsearchresp.cpp
// Function: SSDPSearchResp::SSDPSearchResp()
SSDPSearchResp::SSDPSearchResp(){
    AddSignatureHeader((char*)"CACHE-CONTROL", (char*)"");
    AddSignatureHeader((char*)"EXT", (char*)"");
    AddSignatureHeader((char*)"LOCATION", (char*)"");
    AddSignatureHeader((char*)"SERVER", (char*)"");
    AddSignatureHeader((char*)"ST", (char*)"");
    AddSignatureHeader((char*)"USN", (char*)"");
    /*
    AddSignatureHeader("BOOTID.UPNP.ORG", "");
     */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6cca
leaq 0x6441(%rip), %rax      # 0xccb8
movq %rax, (%rbx)
leaq 0x1c2a(%rip), %rsi      # 0x84ab
leaq 0x1ad9(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x1d4a(%rip), %rsi      # 0x85e1
leaq 0x1ac3(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x1c0c(%rip), %rsi      # 0x84b9
leaq 0x1aad(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x1c11(%rip), %rsi      # 0x84d4
leaq 0x1a97(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x1bcf(%rip), %rsi      # 0x84a8
leaq 0x1a81(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
leaq 0x1bec(%rip), %rsi      # 0x84db
leaq 0x1a6b(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5862
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5736
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/ssdptools.cpp
// Function: cachecontroltoi(unsigned char*, unsigned int)
int cachecontroltoi(u8* s, u32 l){
    u32 ret = -1;
    u32 p;

    char buf[1024];
    int buflen=1024;

    if((int)l >= buflen){
        return ret;
    }

    memcpy(&buf, s, l);
    buf[l]=0;

    //max-age=nn
    trimspaces(&s, &l);
    if(l >= 7 && caseinstringcmp(s, 7, (u8*)"max-age", 7) == 0){
        //search the =
        p = getchar((u8*)buf, (unsigned int)strlen(buf), '=');
        if(p > 0){
            ret = atoi(buf+p+1);
        }
    }

    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
pushq $-0x1
popq %rbx
cmpl $0x3ff, %esi            # imm = 0x3FF
jg 0x7199
movq %rdi, %rax
movl %esi, %r14d
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x31e0
movb $0x0, 0x10(%rsp,%r14)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x37b6
cmpl $0x7, (%r14)
jb 0x7199
movq 0x8(%rsp), %rdi
leaq 0x1506(%rip), %rdx      # 0x8662
pushq $0x7
popq %rcx
movl %ecx, %esi
callq 0x3747
testl %eax, %eax
jne 0x7199
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x30e0
pushq $0x3d
popq %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x37f5
testl %eax, %eax
je 0x7199
movl %eax, %eax
leaq (%rsp,%rax), %rdi
addq $0x11, %rdi
callq 0x3380
movl %eax, %ebx
movl %ebx, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    int timeout = 3;
    int c;
    while ( ((c = getopt( argc, argv, "t:?" ) ) ) != -1 )
    {
        switch (c)
        {
        case 't':
          timeout = atoi(optarg);
          break;
        case '?':
          default:
        usage(argv[0]);
        return -1;
        }
    }


    SSDP* ssdp = new SSDP();
    SSDPDB* db = ssdp->GetDB();
    MainClass mm(db, timeout==0);
    db->AddObserver(&mm);
    ssdp->AddObserver(&mm);
    ssdp->Start();
    
    int t = 0;
    while(timeout == 0 || t < timeout){
        ssdp->Search();
        sleep(timeout==0?15:1);
        t += 1;
    }

    mm.dump_results();

    delete(ssdp);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movl %edi, %ebp
pushq $0x3
popq %rbx
leaq 0x1451(%rip), %r15      # 0x86e6
movq 0x5d2c(%rip), %r12      # 0xcfc8
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3090
cmpl $0x74, %eax
jne 0x72bb
movq (%r12), %rdi
callq 0x3380
movl %eax, %ebx
jmp 0x729c
cmpl $-0x1, %eax
jne 0x7352
movl $0x250, %edi            # imm = 0x250
callq 0x3260
movq %rax, %r14
movq %rax, %rdi
callq 0x3848
movq %r14, %rdi
callq 0x46f6
testl %ebx, %ebx
leaq 0x8(%rsp), %rsi
leaq 0x5a39(%rip), %rcx      # 0xcd28
movq %rcx, -0x8(%rsi)
leaq 0x5a4e(%rip), %rcx      # 0xcd48
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
sete 0x10(%rsi)
pushq $0xf
popq %rcx
pushq $0x1
popq %rbp
cmovel %ecx, %ebp
movq %rax, %rdi
callq 0x4ed8
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4386
movq %r14, %rdi
callq 0x3a2e
xorl %r15d, %r15d
testl %ebx, %ebx
sete %al
cmpl %ebx, %r15d
setl %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x735f
movq %r14, %rdi
callq 0x4198
movl %ebp, %edi
callq 0x3190
incl %r15d
jmp 0x732c
movq (%r14), %rdi
callq 0x7238
pushq $-0x1
popq %rax
jmp 0x7372
movq %rsp, %rdi
callq 0x7398
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x250, %esi            # imm = 0x250
movq %r14, %rdi
callq 0x3280
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/brunokeymolen[P]ssdp/src/main.cpp
// Function: MainClass::dump_results()
void dump_results()
    {
          db_->Lock();
          vector<SSDPDBDevice*>devices = db_->GetDevices();
          std::vector<SSDPDBDevice*>::iterator it;
          int x = 0;
          for(it=devices.begin();it<devices.end();it++){
              x++;
              printf("%.3d. usn=%s, type=%s, version=%s, location=%s\n", x, ((SSDPDBDevice*)*it)->usn.c_str(), ((SSDPDBDevice*)*it)->type.c_str(), ((SSDPDBDevice*)*it)->version.c_str(), ((SSDPDBDevice*)*it)->location.c_str());
          }
          db_->Unlock();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x4b86
movq 0x10(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x4e60
pushq $0x1
popq %rbp
movq (%r14), %r15
leaq 0x1320(%rip), %r14      # 0x86ea
cmpq 0x8(%rsp), %r15
jae 0x7401
movq (%r15), %rax
movq 0x48(%rax), %rdx
movq 0xb8(%rax), %rcx
movq 0xd8(%rax), %r8
movq 0x118(%rax), %r9
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x3040
addq $0x8, %r15
incl %ebp
jmp 0x73ca
movq 0x10(%rbx), %rdi
callq 0x4b90
movq %rsp, %rdi
callq 0x51c4
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51c4
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: Program::getStringRepr[abi:cxx11]()
std::string Program::getStringRepr()
{
	std::string res;

	for (auto stmt : statements)
		res += stmt->getStringRepr() + "\n";

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %rbp
leaq 0x8(%rsp), %r14
leaq 0x10d64(%rip), %r15     # 0x1c81d
leaq 0x28(%rsp), %r12
cmpq %rbp, %r13
je 0xbaff
movq (%r13), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5388
addq $0x8, %r13
jmp 0xbabe
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xbb32
movq %rax, %r14
jmp 0xbb28
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: ExpressionStatement::getStringRepr[abi:cxx11]()
std::string ExpressionStatement::getStringRepr()
{
	std::string res = "";

	if (expression != nullptr)
		res += expression->getStringRepr();

	res.push_back(';');

	return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x109ec(%rip), %rsi     # 0x1c81e
leaq 0x8(%rsp), %rdx
callq 0x9da4
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0xbe67
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5360
leaq 0x8(%rsp), %rdi
callq 0x5388
pushq $0x3b
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0xbe91
jmp 0xbe8e
movq %rax, %r14
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: BlockStatement::getStringRepr[abi:cxx11]()
std::string BlockStatement::getStringRepr()
{
	if (statements.size() == 0)
		return "{ }";

	std::string res = "{ ";
	for (auto stmt : statements)
		res += stmt->getStringRepr() + " ";

	res += " }";

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x50(%rsi), %rax
cmpq 0x48(%rsi), %rax
je 0xc10d
movq %rsi, %r15
leaq 0x10142(%rip), %rsi     # 0x1c1d9
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9da4
movq 0x48(%r15), %r13
movq 0x50(%r15), %rbp
leaq 0x28(%rsp), %r15
leaq 0x10137(%rip), %r12     # 0x1c1f2
cmpq %rbp, %r13
je 0xc0fc
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5360
movq %r14, %rdi
callq 0x5388
movq %r15, %rdi
callq 0x5388
addq $0x8, %r13
jmp 0xc0bb
leaq 0x100ce(%rip), %rsi     # 0x1c1d1
movq %rbx, %rdi
callq 0x5350
jmp 0xc121
leaq 0x100bc(%rip), %rsi     # 0x1c1d0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x9da4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc135
movq %rax, %r14
jmp 0xc156
movq %rax, %r14
jmp 0xc14c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: IfExpression::getStringRepr[abi:cxx11]()
std::string IfExpression::getStringRepr()
{
	std::string res = "if " + std::string("(") + condition->getStringRepr() + ")" + " { " + consequence->getStringRepr() + " }";
	if (alternative != nullptr)
		res += " else {" + alternative->getStringRepr() + " }";

	return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1006d(%rip), %rsi     # 0x1c1ea
leaq 0xa8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9da4
leaq 0x1003e(%rip), %rsi     # 0x1c1d4
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xd257
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq 0x88(%rsp), %rdi
callq *0x8(%rax)
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0xd149
leaq 0x10925(%rip), %rdx     # 0x1cb06
leaq 0x8(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xd12a
leaq 0xffde(%rip), %rdx      # 0x1c1d8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd12a
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq 0x68(%rsp), %rdi
callq *0x8(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0xd149
leaq 0xff9e(%rip), %rdx      # 0x1c1d1
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xd12a
leaq 0x48(%rsp), %rdi
callq 0x5388
leaq 0x68(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0xe8(%rsp), %rdi
callq 0x5388
leaq 0x88(%rsp), %rdi
callq 0x5388
leaq 0xc8(%rsp), %rdi
callq 0x5388
leaq 0xa8(%rsp), %rdi
callq 0x5388
movq 0x58(%r14), %rsi
testq %rsi, %rsi
je 0xc307
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
leaq 0xff25(%rip), %rsi      # 0x1c1dc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd257
leaq 0xff04(%rip), %rdx      # 0x1c1d1
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd12a
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x5360
leaq 0x48(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5388
jmp 0xc327
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0xc336
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0xc345
movq %rax, %r14
movq %rbx, %rdi
jmp 0xc3b8
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5388
jmp 0xc35c
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x5388
jmp 0xc36b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0xc37a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0xc389
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
callq 0x5388
leaq 0x88(%rsp), %rdi
callq 0x5388
leaq 0xc8(%rsp), %rdi
callq 0x5388
leaq 0xa8(%rsp), %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
movq %rax, %r14
jmp 0xc396
movq %rax, %r14
jmp 0xc3a3
movq %rax, %r14
jmp 0xc3b0
movq %rax, %r14
jmp 0xc3bd
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: FunctionLiteral::getStringRepr[abi:cxx11]()
std::string FunctionLiteral::getStringRepr()
{
	std::string res = tokenLiteral() + "(";
	for (auto param : parameters)
		res += param->getStringRepr() + ", ";

	if (parameters.size() != 0)
	{

		res.pop_back();
		res.pop_back();
	}

	res += ") {";
	res += body->getStringRepr();
	res += " }";

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *(%rax)
leaq 0xfcce(%rip), %rdx      # 0x1c1ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd12a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5388
movq 0x48(%r14), %rbp
movq %r14, (%rsp)
movq 0x50(%r14), %r14
leaq 0x28(%rsp), %r12
leaq 0xfca5(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0xc58d
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0xc54c
movq (%rsp), %r14
movq 0x50(%r14), %rax
cmpq 0x48(%r14), %rax
je 0xc5ab
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
leaq 0xfc3b(%rip), %rsi      # 0x1c1ed
movq %rbx, %rdi
callq 0x5350
movq 0x60(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5360
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0xfbea(%rip), %rsi      # 0x1c1d1
movq %rbx, %rdi
callq 0x5350
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xc635
jmp 0xc619
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xc63d
jmp 0xc619
movq %rax, %r14
jmp 0xc63a
movq %rax, %r14
jmp 0xc630
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: CallExpression::getStringRepr[abi:cxx11]()
std::string CallExpression::getStringRepr()
{
	std::string res = function->getStringRepr() + "(";

	for (auto arg : arguments)
		res += arg->getStringRepr() + ", ";

	if (arguments.size() != 0)
	{
		res.pop_back();
		res.pop_back();
	}

	res.push_back(')');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x8(%rax)
leaq 0xfb73(%rip), %rdx      # 0x1c1ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd12a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5388
movq 0x50(%r14), %rbp
movq %r14, (%rsp)
movq 0x58(%r14), %r14
leaq 0x28(%rsp), %r12
leaq 0xfb4a(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0xc6e8
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0xc6a7
movq (%rsp), %rcx
movq 0x58(%rcx), %rax
cmpq 0x50(%rcx), %rax
je 0xc706
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc72f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xc753
movq %rax, %r14
jmp 0xc750
movq %rax, %r14
jmp 0xc746
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: ArrayLiteral::getStringRepr[abi:cxx11]()
std::string ArrayLiteral::getStringRepr()
{
	std::string res = "[";

	for (auto elem : elements)
		res += elem->getStringRepr() + ", ";

	if (elements.size() != 0)
	{
		res.pop_back();
		res.pop_back();
	}

	res.push_back(']');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf8c8(%rip), %rsi      # 0x1c043
leaq 0x28(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq 0x48(%r14), %rbp
movq %r14, (%rsp)
movq 0x50(%r14), %r14
leaq 0x8(%rsp), %r12
leaq 0xfa51(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0xc7e1
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0xc7a0
movq (%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0xc7ff
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc81e
movq %rax, %r14
jmp 0xc83f
movq %rax, %r14
jmp 0xc835
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: HashMapLiteral::getStringRepr[abi:cxx11]()
std::string HashMapLiteral::getStringRepr()
{
	std::string res = "{";

	for (auto pair : pairs)
		res += pair.key->getStringRepr() + " : " + pair.value->getStringRepr() + ", ";

	if (pairs.size() != 0)
	{
		res.pop_back();
		res.pop_back();
	}

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf89f(%rip), %rsi      # 0x1c1ef
leaq 0x98(%rsp), %rbp
movq %rbp, %rdx
callq 0x9da4
movq 0x48(%r14), %r15
movq %r14, 0x8(%rsp)
movq 0x50(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rsp), %r13
cmpq 0x10(%rsp), %r15
je 0xca26
movq %rbx, %r12
movq (%r15), %rsi
movq 0x8(%r15), %rbx
movq (%rsi), %rax
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
leaq 0xf84b(%rip), %rdx      # 0x1c1f4
callq 0xd12a
movq (%rbx), %rax
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
movq %r12, %rbx
callq 0xd149
movq %rbp, %rdi
movq %r13, %rsi
leaq 0xf812(%rip), %rdx      # 0x1c1f1
callq 0xd12a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5360
movq %rbp, %rdi
callq 0x5388
movq %r13, %rdi
callq 0x5388
leaq 0x38(%rsp), %rdi
callq 0x5388
leaq 0x18(%rsp), %rdi
callq 0x5388
leaq 0x58(%rsp), %rdi
callq 0x5388
addq $0x10, %r15
jmp 0xc977
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0xca45
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xcac1
movq %rax, %r14
jmp 0xca9d
movq %rax, %r14
jmp 0xca93
movq %rax, %r14
jmp 0xca89
movq %rax, %r14
leaq 0x98(%rsp), %rdi
callq 0x5388
leaq 0x78(%rsp), %rdi
callq 0x5388
leaq 0x38(%rsp), %rdi
callq 0x5388
leaq 0x18(%rsp), %rdi
callq 0x5388
jmp 0xcab4
movq %rax, %r14
movq %r12, %rbx
jmp 0xcac1
movq %rax, %r14
movq %r12, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: HashSetLiteral::getStringRepr[abi:cxx11]()
std::string HashSetLiteral::getStringRepr()
{
	std::string res = "hashset<> {";

	for (auto pair : pairs)
		res += pair->getStringRepr() + ", ";

	if (pairs.size() != 0)
	{
		res.pop_back();
		res.pop_back();
	}

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf70b(%rip), %rsi      # 0x1c1f8
leaq 0x28(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq 0x48(%r14), %rbp
movq %r14, (%rsp)
movq 0x50(%r14), %r14
leaq 0x8(%rsp), %r12
leaq 0xf6df(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0xcb53
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0xcb12
movq (%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0xcb71
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcb90
movq %rax, %r14
jmp 0xcbb1
movq %rax, %r14
jmp 0xcba7
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: StackLiteral::getStringRepr[abi:cxx11]()
std::string StackLiteral::getStringRepr()
{
	std::string res = "stack<> {";

	for (auto elem : elements)
		res += elem->getStringRepr() + ", ";

	if (elements.size() != 0)
	{
		res.pop_back();
		res.pop_back();
	}

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf627(%rip), %rsi      # 0x1c204
leaq 0x28(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq 0x48(%r14), %rbp
movq %r14, (%rsp)
movq 0x50(%r14), %r14
leaq 0x8(%rsp), %r12
leaq 0xf5ef(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0xcc43
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0xcc02
movq (%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0xcc61
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcc80
movq %rax, %r14
jmp 0xcca1
movq %rax, %r14
jmp 0xcc97
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/ast.cpp
// Function: DequeLiteral::getStringRepr[abi:cxx11]()
std::string DequeLiteral::getStringRepr()
{
	std::string res = "deque<> {";

	for (auto elem : elements)
		res += elem->getStringRepr() + ", ";

	if (elements.size() != 0)
	{
		res.pop_back();
		res.pop_back();
	}

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf45b(%rip), %rsi      # 0x1c218
leaq 0x28(%rsp), %r15
movq %r15, %rdx
callq 0x9da4
movq 0x48(%r14), %rbp
movq %r14, (%rsp)
movq 0x50(%r14), %r14
leaq 0x8(%rsp), %r12
leaq 0xf40f(%rip), %r13      # 0x1c1f1
cmpq %r14, %rbp
je 0xce23
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd12a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5388
movq %r12, %rdi
callq 0x5388
addq $0x8, %rbp
jmp 0xcde2
movq (%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0xce41
movq %rbx, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5210
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x5190
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xce60
movq %rax, %r14
jmp 0xce81
movq %rax, %r14
jmp 0xce77
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5388
leaq 0x8(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5388
movq %r14, %rdi
callq 0x5330
nop