LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rax
cmpq %rax, %r14
jae 0x69ae
movq (%r14), %rdi
callq 0x32d0
addq $0x8, %r14
movq 0x10(%rbx), %rax
jmp 0x6997
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x69bb
movq %rcx, 0x10(%rbx)
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rax
cmpq %rax, %r14
jae 0x69dc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x69d6
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x69bf
movq 0x20(%rbx), %rdi
cmpq %rdi, %rax
je 0x69e9
movq %rdi, 0x28(%rbx)
testq %rdi, %rdi
je 0x69fa
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x3280
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6a16
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3280
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %r14, 0x10(%rdi)
je 0x6a53
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jae 0x6a46
movq (%r14), %rdi
callq 0x32d0
addq $0x8, %r14
jmp 0x6a2f
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x6a53
movq %rcx, 0x10(%rbx)
movq 0x20(%rbx), %r14
cmpq 0x28(%rbx), %r14
jae 0x6a6c
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x8, %r14
jmp 0x6a57
movl $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, %edx
jb 0x6dec
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movl %edx, %edx
leaq 0x159b(%rip), %rsi      # 0x835f
movq %r14, %rdi
callq 0x6dfb
testq %rax, %rax
je 0x6dec
addq $0x2, %rax
subl %eax, %r14d
addl %r14d, %ebp
movl %ebp, (%r12)
je 0x6dec
movq %rax, (%r15)
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
subl %r14d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3100
testq %rax, %rax
je 0x6e4d
movq %rax, %r12
leaq (%rbx,%r14), %rax
subq %r12, %rax
incq %rax
cmpq %rbx, %rax
jbe 0x6e4b
incq %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3110
testl %eax, %eax
je 0x6e4d
incq %rbx
decq %r14
cmpq %r14, %r12
jne 0x6e2e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5cb0
leaq 0x4c41(%rip), %rax      # 0xbc80
movq %rax, (%rbx)
leaq 0x1462(%rip), %rsi      # 0x84ab
leaq 0x1311(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5e1e
leaq 0x15c9(%rip), %rsi      # 0x8628
leaq 0x12fb(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5e1e
leaq 0x1444(%rip), %rsi      # 0x84b9
leaq 0x12e5(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5e1e
leaq 0x1449(%rip), %rsi      # 0x84d4
leaq 0x12cf(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5e1e
leaq 0x1407(%rip), %rsi      # 0x84a8
leaq 0x12b9(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5e1e
leaq 0x1424(%rip), %rsi      # 0x84db
leaq 0x12a3(%rip), %rdx      # 0x8361
movq %rbx, %rdi
callq 0x5e1e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5cc6
movq %r14, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3ff, %esi            # imm = 0x3FF
jg 0x7a5f
movq %rdi, %rax
movl %esi, %r14d
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x31f0
movb $0x0, 0x10(%rsp,%r14)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x3899
cmpl $0x7, (%r14)
jb 0x7a5f
movq 0x8(%rsp), %rdi
leaq 0xc87(%rip), %rdx       # 0x86a2
movl $0x7, %esi
movl $0x7, %ecx
callq 0x380a
testl %eax, %eax
jne 0x7a5f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3100
movq %r14, %rdi
movl %eax, %esi
movl $0x3d, %edx
callq 0x38e7
testl %eax, %eax
je 0x7a5f
movl %eax, %eax
leaq (%rsp,%rax), %rdi
addq $0x11, %rdi
callq 0x33a0
movl %eax, %ebx
movl %ebx, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x3, %ebx
leaq 0xb47(%rip), %r15       # 0x8726
movq 0x43e2(%rip), %r12      # 0xbfc8
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x30a0
cmpl $0x74, %eax
jne 0x7c05
movq (%r12), %rdi
callq 0x33a0
movl %eax, %ebx
jmp 0x7be6
cmpl $-0x1, %eax
jne 0x7cb7
movl $0x250, %edi            # imm = 0x250
callq 0x3260
movq %rax, %r14
movq %rax, %rdi
callq 0x3940
movq %r14, %rdi
callq 0x4b34
leaq 0x8(%rsp), %rsi
leaq 0x40b9(%rip), %rcx      # 0xbcf0
movq %rcx, -0x8(%rsi)
leaq 0x40ce(%rip), %rcx      # 0xbd10
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
testl %ebx, %ebx
sete 0x10(%rsi)
movq %rax, %rdi
callq 0x5360
movq %rsp, %rsi
movq %r14, %rdi
callq 0x46a6
movq %r14, %rdi
callq 0x3bc4
testl %ebx, %ebx
js 0x7ca2
movl $0xf, %ebp
movl $0x1, %r15d
cmovnel %r15d, %ebp
testl %ebx, %ebx
sete %r12b
movq %r14, %rdi
callq 0x43f2
movl %ebp, %edi
callq 0x31a0
cmpl %ebx, %r15d
setl %al
orb %r12b, %al
incl %r15d
testb %al, %al
jne 0x7c7d
movq %rsp, %rdi
callq 0x7cea
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x7cc4
movq (%r14), %rdi
callq 0x7b04
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f24
movq 0x10(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x52e2
movq (%r14), %r15
cmpq 0x8(%r14), %r15
jae 0x7d59
movl $0x1, %ebp
leaq 0xa06(%rip), %r14       # 0x872a
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 0x3050
addq $0x8, %r15
incl %ebp
cmpq 0x8(%rsp), %r15
jb 0x7d24
movq 0x10(%rbx), %rdi
callq 0x4f2e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7d78
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7d9c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rbp
movq 0x10(%rsi), %r13
cmpq %r13, %rbp
je 0xe925
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r14
leaq 0x1af76(%rip), %r15     # 0x297ee
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5360
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xe8b3
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xe8bb
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe8fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe918
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0xe878
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe977
movq %rax, %r14
jmp 0xe95b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe95b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe977
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xe98f
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x1a628(%rip), %rdx     # 0x297ef
movq %rdx, %rsi
callq 0xbe78
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0xf20d
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x8(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf20d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x5180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf24c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0xf24c
jmp 0xf249
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xf25f
movq (%r15), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x10(%rdi), %rcx
cmpq 0x48(%rsi), %rax
movq %rcx, (%rdi)
je 0xf897
movq %rsi, %r14
movq %rcx, (%rsp)
leaq 0x199f1(%rip), %rsi     # 0x29199
leaq 0x199ec(%rip), %rdx     # 0x2919b
movq %rbx, %rdi
callq 0xbe78
movq 0x48(%r14), %rbp
movq 0x50(%r14), %r13
cmpq %r13, %rbp
je 0xf886
leaq 0x18(%rsp), %r12
leaq 0x28(%rsp), %r14
leaq 0x199d9(%rip), %r15     # 0x291b2
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5360
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xf814
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xf81c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf85d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xf879
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0xf7d9
leaq 0x19904(%rip), %rsi     # 0x29191
movq %rbx, %rdi
callq 0x5360
jmp 0xf8ad
leaq 0x198f2(%rip), %rsi     # 0x29190
leaq 0x198ee(%rip), %rdx     # 0x29193
movq %rbx, %rdi
callq 0xbe78
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf8c1
movq %rax, %r14
jmp 0xf901
movq %rax, %r14
jmp 0xf8e5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf8e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xf901
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xf919
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x48(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18bbb(%rip), %rsi     # 0x291aa
movq %r15, %rdi
callq 0x5360
leaq 0x10(%rbx), %rsi
movq %rsi, (%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq %rsi, 0x28(%rsp)
je 0x1061e
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x10624
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x10656
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x50(%r12), %r14
movq %r12, 0x30(%rsp)
movq 0x58(%r12), %rbp
cmpq %rbp, %r14
je 0x10726
leaq 0x38(%rsp), %r15
leaq 0x18b37(%rip), %r12     # 0x291b1
movq (%r14), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x106b4
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x106bc
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x106fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x10719
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r14
cmpq %rbp, %r14
jne 0x1067a
movq 0x30(%rsp), %rcx
movq 0x58(%rcx), %rax
cmpq 0x50(%rcx), %rax
je 0x10745
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x29, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1077e
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x107d8
movq 0x18(%rsp), %rsi
jmp 0x107d0
movq %rax, %r14
jmp 0x107be
movq %rax, %r14
jmp 0x107a2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x107a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x107be
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x28(%rsp), %rdi
je 0x107d8
movq 0x28(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x18981(%rip), %rsi     # 0x29188
leaq 0x1897b(%rip), %rdx     # 0x29189
callq 0xbe78
movq 0x48(%r14), %r13
movq %r14, 0x30(%rsp)
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x108e6
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x18977(%rip), %r12     # 0x291b1
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x10875
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x1087c
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x108bd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x108d9
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x1083a
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x10905
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10926
movq %rax, %r15
jmp 0x10966
movq %rax, %r15
jmp 0x1094a
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1094a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x10966
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x10980
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x181e5(%rip), %rsi     # 0x291b8
leaq 0x181e9(%rip), %rdx     # 0x291c3
callq 0xbe78
movq 0x48(%r14), %r13
movq %r14, 0x30(%rsp)
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x110b2
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x181ab(%rip), %r12     # 0x291b1
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x11041
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x11048
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11089
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x110a5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x11006
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x110d1
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x110f2
movq %rax, %r15
jmp 0x11132
movq %rax, %r15
jmp 0x11116
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11116
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x11132
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x1114c
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x18049(%rip), %rsi     # 0x291c4
leaq 0x1804b(%rip), %rdx     # 0x291cd
callq 0xbe78
movq 0x48(%r14), %r13
movq %r14, 0x30(%rsp)
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x1125a
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x18003(%rip), %r12     # 0x291b1
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x111e9
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x111f0
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11231
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1124d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x111ae
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x11279
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1129a
movq %rax, %r15
jmp 0x112da
movq %rax, %r15
jmp 0x112be
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x112be
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x112da
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x112f4
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x17d0d(%rip), %rsi     # 0x291d8
leaq 0x17d0f(%rip), %rdx     # 0x291e1
callq 0xbe78
movq 0x48(%r14), %r13
movq %r14, 0x30(%rsp)
movq 0x50(%r14), %rbp
cmpq %rbp, %r13
je 0x115aa
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x17cb3(%rip), %r12     # 0x291b1
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x11539
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x11540
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11581
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1159d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x114fe
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rax
cmpq 0x48(%rcx), %rax
je 0x115c9
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x115ea
movq %rax, %r15
jmp 0x1162a
movq %rax, %r15
jmp 0x1160e
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1160e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1162a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x11644
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseStringLiteral()
Expression *Parser::parseStringLiteral()
{
	StringLiteral *s = new StringLiteral();
	s->token = curToken;
	s->value = curToken.literal;
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x68, %edi
callq 0x51b0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
xorl %eax, %eax
movq %rax, 0x60(%r14)
leaq 0x206ad(%rip), %rcx     # 0x349b8
movq %rcx, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movb %al, 0x38(%r14)
leaq 0x48(%r14), %r12
leaq 0x58(%r14), %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
leaq 0x30(%rbx), %rsi
callq 0x5100
addq $0x50, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5100
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parsePrefixExpression()
Expression *Parser::parsePrefixExpression()
{
	PrefixExpression *exp = new PrefixExpression();
	exp->token = curToken;
	exp->operand = curToken.literal;

	nextToken();

	exp->right = parseExpression(PREFIX);
	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x70, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
leaq 0x1fef6(%rip), %rax     # 0x342b0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x48(%rbx), %r12
leaq 0x58(%rbx), %rcx
movq %rcx, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movb %al, 0x58(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x5100
movq %r12, %rdi
movq %r13, %rsi
callq 0x5100
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
movl $0x5, %esi
callq 0x162f0
movq %rax, 0x68(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseBooleanLiteral()
Expression *Parser::parseBooleanLiteral()
{
	BooleanLiteral *ident = new BooleanLiteral();
	ident->token = curToken;
	ident->value = curToken.type == TRUE;
	return ident;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x50, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x204dc(%rip), %rax     # 0x34958
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %r13d, %r13d
movq %r13, 0x10(%rbx)
movb %r13b, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movb %r13b, 0x38(%rbx)
leaq 0x30(%r14), %r15
movq %r15, %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r12, %rdi
callq 0x5100
movq 0x38(%r14), %rdx
cmpq 0x2274b(%rip), %rdx     # 0x36c18
jne 0x144ee
testq %rdx, %rdx
je 0x144eb
movq 0x22735(%rip), %rsi     # 0x36c10
movq (%r15), %rdi
callq 0x51d0
testl %eax, %eax
sete %r13b
jmp 0x144ee
movb $0x1, %r13b
movb %r13b, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseIfExpression()
Expression *Parser::parseIfExpression()
{
	IfExpression *exp = new IfExpression();
	exp->token = curToken;

	// condition
	if (!expectPeek(LPAREN))
	{
		delete exp;
		return nullptr;
	}
	nextToken();
	exp->condition = parseExpression(LOWEST);
	if (!expectPeek(RPAREN))
	{
		delete exp;
		return nullptr;
	}

	// consequence
	if (!expectPeek(LBRACE))
	{
		delete exp;
		return nullptr;
	}
	exp->consequence = parseBlockStatement();

	// else
	if (peekToken.type == ELSE)
	{
		nextToken();
		if (!expectPeek(LBRACE))
		{
			delete exp;
			return nullptr;
		}
		exp->alternative = parseBlockStatement();
	}
	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
leaq 0x1fe92(%rip), %rax     # 0x343c8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x225cf(%rip), %rsi     # 0x36b50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14628
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x48(%rbx)
leaq 0x225c2(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14628
leaq 0x225cf(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14628
movq %r14, %rdi
callq 0x16adc
movq %rax, 0x50(%rbx)
movq 0x78(%r14), %rdx
cmpq 0x226b4(%rip), %rdx     # 0x36c98
jne 0x14633
testq %rdx, %rdx
je 0x145ff
movq 0x2269e(%rip), %rsi     # 0x36c90
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
jne 0x14633
movq %r14, %rdi
callq 0x13d4c
leaq 0x22582(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14628
movq %r14, %rdi
callq 0x16adc
movq %rax, 0x58(%rbx)
jmp 0x14633
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseWhileExpression()
Expression *Parser::parseWhileExpression()
{
	WhileExpression *exp = new WhileExpression();
	exp->token = curToken;

	if (!expectPeek(LPAREN))
	{
		delete exp;
		return nullptr;
	}

	nextToken();

	exp->condition = parseExpression(LOWEST);

	if (!expectPeek(RPAREN))
		return nullptr;

	if (!expectPeek(LBRACE))
		return nullptr;

	exp->consequence = parseBlockStatement();

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x58, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
xorl %eax, %eax
movq %rax, 0x50(%rbx)
leaq 0x1fdb4(%rip), %rcx     # 0x34428
addq $0x10, %rcx
movq %rcx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x22493(%rip), %rsi     # 0x36b50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14713
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x48(%rbx)
leaq 0x2248a(%rip), %rsi     # 0x36b70
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x1471c
leaq 0x22497(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x1471c
movq %r14, %rdi
callq 0x16adc
movq %rax, 0x50(%rbx)
jmp 0x1471e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseFunctionLiteral()
Expression *Parser::parseFunctionLiteral()
{
	FunctionLiteral *fn = new FunctionLiteral();
	fn->token = curToken;

	if (!expectPeek(LPAREN))
	{ // in this function, only deal with "("
		delete fn;
		return nullptr;
	}

	fn->parameters = parseFunctionParameters();

	if (!expectPeek(LBRACE))
	{
		delete fn;
		return nullptr;
	}

	fn->body = parseBlockStatement();
	return fn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x68, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
xorl %eax, %eax
movq %rax, 0x60(%rbx)
leaq 0x1fd1e(%rip), %rcx     # 0x34488
addq $0x10, %rcx
movq %rcx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x22395(%rip), %rsi     # 0x36b50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x1481e
movq %rbx, %r15
addq $0x48, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x16c16
movq %r15, %rdi
movq %r12, %rsi
callq 0x18cb8
movq (%r12), %rdi
testq %rdi, %rdi
je 0x147fd
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
leaq 0x2238c(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x1481e
movq %r14, %rdi
callq 0x16adc
movq %rax, 0x60(%rbx)
jmp 0x14829
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseHashSetLiteral()
Expression *Parser::parseHashSetLiteral()
{
	HashSetLiteral *exp = new HashSetLiteral();
	exp->token = curToken;

	if (!expectPeek(LT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(GT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(LBRACE))
	{
		delete exp;
		return nullptr;
	}

	while (peekToken.type != RBRACE)
	{
		nextToken();

		Expression *value = parseExpression(LOWEST);

		exp->pairs.push_back(value);

		if (peekToken.type != RBRACE && !expectPeek(COMMA))
			return nullptr;
	}

	if (!expectPeek(RBRACE))
	{
		delete exp;
		return nullptr;
	}

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1fd92(%rip), %rax     # 0x34608
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x22167(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x149cc
leaq 0x22170(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x149cc
leaq 0x22299(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x149cc
movq %rbx, %r15
addq $0x48, %r15
leaq 0x8(%rsp), %r12
leaq 0x221d6(%rip), %r13     # 0x36af0
movq 0x78(%r14), %rdx
cmpq 0x22293(%rip), %rdx     # 0x36bb8
jne 0x14944
testq %rdx, %rdx
je 0x149b9
movq 0x22279(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x149b9
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x8(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x1496f
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x1497a
movq %r15, %rdi
movq %r12, %rdx
callq 0x19120
movq 0x78(%r14), %rdx
cmpq 0x22233(%rip), %rdx     # 0x36bb8
jne 0x149a4
testq %rdx, %rdx
je 0x1491a
movq 0x2221d(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x1491a
movq %r14, %rdi
movq %r13, %rsi
callq 0x1629e
testb %al, %al
jne 0x1491a
jmp 0x149d5
leaq 0x221f0(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x1629e
testb %al, %al
jne 0x149d7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseStackLiteral()
Expression *Parser::parseStackLiteral()
{
	StackLiteral *exp = new StackLiteral();
	exp->token = curToken;

	if (!expectPeek(LT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(GT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(LBRACE))
	{
		delete exp;
		return nullptr;
	}

	while (peekToken.type != RBRACE)
	{
		nextToken();

		Expression *value = parseExpression(LOWEST);

		exp->elements.push_back(value);

		if (peekToken.type != RBRACE && !expectPeek(COMMA))
			return nullptr;
	}

	if (!expectPeek(RBRACE))
	{
		delete exp;
		return nullptr;
	}

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1fc42(%rip), %rax     # 0x34668
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x21fb7(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14b7c
leaq 0x21fc0(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14b7c
leaq 0x220e9(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14b7c
movq %rbx, %r15
addq $0x48, %r15
leaq 0x8(%rsp), %r12
leaq 0x22026(%rip), %r13     # 0x36af0
movq 0x78(%r14), %rdx
cmpq 0x220e3(%rip), %rdx     # 0x36bb8
jne 0x14af4
testq %rdx, %rdx
je 0x14b69
movq 0x220c9(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x14b69
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x8(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x14b1f
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x14b2a
movq %r15, %rdi
movq %r12, %rdx
callq 0x19120
movq 0x78(%r14), %rdx
cmpq 0x22083(%rip), %rdx     # 0x36bb8
jne 0x14b54
testq %rdx, %rdx
je 0x14aca
movq 0x2206d(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x14aca
movq %r14, %rdi
movq %r13, %rsi
callq 0x1629e
testb %al, %al
jne 0x14aca
jmp 0x14b85
leaq 0x22040(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x1629e
testb %al, %al
jne 0x14b87
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/parser.cpp
// Function: Parser::parseQueueLiteral()
Expression *Parser::parseQueueLiteral()
{
	QueueLiteral *exp = new QueueLiteral();
	exp->token = curToken;

	if (!expectPeek(LT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(GT))
	{
		delete exp;
		return nullptr;
	}

	if (!expectPeek(LBRACE))
	{
		delete exp;
		return nullptr;
	}

	while (peekToken.type != RBRACE)
	{
		nextToken();

		Expression *value = parseExpression(LOWEST);

		exp->elements.push_back(value);

		if (peekToken.type != RBRACE && !expectPeek(COMMA))
			return nullptr;
	}

	if (!expectPeek(RBRACE))
		return nullptr;

	return exp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x51b0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x1faf2(%rip), %rax     # 0x346c8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
leaq 0x30(%r14), %rsi
callq 0x5100
leaq 0x50(%r14), %rsi
movq %r15, %rdi
callq 0x5100
leaq 0x21e07(%rip), %rsi     # 0x36a30
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14d1a
leaq 0x21e10(%rip), %rsi     # 0x36a50
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14d1a
leaq 0x21f39(%rip), %rsi     # 0x36b90
movq %r14, %rdi
callq 0x1629e
testb %al, %al
je 0x14d1a
leaq 0x48(%rbx), %r15
leaq 0x8(%rsp), %r12
leaq 0x21e79(%rip), %r13     # 0x36af0
movq 0x78(%r14), %rdx
cmpq 0x21f36(%rip), %rdx     # 0x36bb8
jne 0x14ca5
testq %rdx, %rdx
je 0x14d33
movq 0x21f1c(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x14d33
movq %r14, %rdi
callq 0x13d4c
movq %r14, %rdi
xorl %esi, %esi
callq 0x162f0
movq %rax, 0x8(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x14cd0
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x14cdb
movq %r15, %rdi
movq %r12, %rdx
callq 0x19120
movq 0x78(%r14), %rdx
cmpq 0x21ed2(%rip), %rdx     # 0x36bb8
jne 0x14d05
testq %rdx, %rdx
je 0x14c77
movq 0x21ebc(%rip), %rsi     # 0x36bb0
movq 0x70(%r14), %rdi
callq 0x51d0
testl %eax, %eax
je 0x14c77
movq %r14, %rdi
movq %r13, %rsi
callq 0x1629e
testb %al, %al
jne 0x14c77
jmp 0x14d23
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x21e76(%rip), %rsi     # 0x36bb0
movq %r14, %rdi
callq 0x1629e
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %rbx, %rax
jmp 0x14d25