LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xe1a0
movq -0x20(%rbp), %rdi
leaq 0xa0ec(%rip), %rax      # 0x17c80
movq %rax, (%rdi)
leaq 0x2915(%rip), %rsi      # 0x104b3
leaq 0x284d(%rip), %rdx      # 0x103f2
callq 0xa5d0
jmp 0xdbac
movq -0x20(%rbp), %rdi
leaq 0x2a3a(%rip), %rsi      # 0x105f1
leaq 0x2834(%rip), %rdx      # 0x103f2
callq 0xa5d0
jmp 0xdbc5
movq -0x20(%rbp), %rdi
leaq 0x28f1(%rip), %rsi      # 0x104c1
leaq 0x281b(%rip), %rdx      # 0x103f2
callq 0xa5d0
jmp 0xdbde
movq -0x20(%rbp), %rdi
leaq 0x28f3(%rip), %rsi      # 0x104dc
leaq 0x2802(%rip), %rdx      # 0x103f2
callq 0xa5d0
jmp 0xdbf7
movq -0x20(%rbp), %rdi
leaq 0x28ae(%rip), %rsi      # 0x104b0
leaq 0x27e9(%rip), %rdx      # 0x103f2
callq 0xa5d0
jmp 0xdc10
movq -0x20(%rbp), %rdi
leaq 0x28c8(%rip), %rsi      # 0x104e3
leaq 0x27d0(%rip), %rdx      # 0x103f2
callq 0xa5d0
jmp 0xdc29
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa250
movq -0x10(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: brunokeymolen[P]ssdp/src/ssdptools.cpp
// Function: GetHeaderValueFromCollection(std::vector<SSDP_HTTP_HEADER*, std::allocator<SSDP_HTTP_HEADER*>>, unsigned char*, int, unsigned char**, int*)
int GetHeaderValueFromCollection(vector<SSDP_HTTP_HEADER*> headers, u8* fieldname, int fieldnamelen, u8** value, int *len){
    int ret=0;
    int found=0;

    vector<SSDP_HTTP_HEADER*>::const_iterator it;
    SSDP_HTTP_HEADER *hdr = nullptr;

    if(headers.size() <= 0){
        ret = -1;
        goto EXIT;
    }

    for(it=headers.begin();it<headers.end();it++){
        hdr = *it;
        if(caseinstringcmp(fieldname, fieldnamelen, hdr->fieldname, hdr->fieldnamelen) == 0){
            //found
            found=1;
            break;
        }
    }

    if(found){
        *value=hdr->fieldvalue;
        *len=hdr->fieldvaluelen;
    }else{
        ret =-1;
    }

EXIT:
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa950
movq -0x68(%rbp), %rdi
movq $0x0, -0x40(%rbp)
callq 0xa970
cmpq $0x0, %rax
ja 0xe289
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0xe343
movq -0x68(%rbp), %rdi
callq 0xa6e0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa990
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rdi
callq 0xa750
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa9d0
testb $0x1, %al
jne 0xe2cb
jmp 0xe316
leaq -0x38(%rbp), %rdi
callq 0xaa10
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x40(%rbp), %rax
movq (%rax), %rdx
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
callq 0x39b0
cmpl $0x0, %eax
jne 0xe303
movl $0x1, -0x30(%rbp)
jmp 0xe316
jmp 0xe305
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xaa30
movq %rax, -0x60(%rbp)
jmp 0xe2ab
cmpl $0x0, -0x30(%rbp)
je 0xe33a
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0xe341
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0xe343
movl -0x2c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x400, -0x424(%rbp)    # imm = 0x400
movl -0x14(%rbp), %eax
cmpl -0x424(%rbp), %eax
jl 0xe889
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe92f
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
leaq -0x420(%rbp), %rdi
callq 0x3230
movl -0x14(%rbp), %eax
movb $0x0, -0x420(%rbp,%rax)
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3b50
cmpl $0x7, -0x14(%rbp)
jb 0xe929
movq -0x10(%rbp), %rdi
movl $0x7, %ecx
leaq 0x1da6(%rip), %rdx      # 0x10672
movl %ecx, %esi
callq 0x39b0
cmpl $0x0, %eax
jne 0xe929
leaq -0x420(%rbp), %rax
movq %rax, -0x430(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x3110
movq -0x430(%rbp), %rdi
movl %eax, %esi
movl $0x3d, %edx
callq 0x3bd0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0xe927
leaq -0x420(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x3460
movl %eax, -0x18(%rbp)
jmp 0xe929
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x1c18(%rip), %rdx      # 0x106f6
callq 0x30b0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0xeb32
movl -0x18(%rbp), %eax
movl %eax, -0x60(%rbp)
subl $0x3f, %eax
je 0xeb16
jmp 0xeaf8
movl -0x60(%rbp), %eax
subl $0x74, %eax
jne 0xeb18
jmp 0xeb02
movq 0x94b7(%rip), %rax      # 0x17fc0
movq (%rax), %rdi
callq 0x3460
movl %eax, -0x14(%rbp)
jmp 0xeb30
jmp 0xeb18
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xea40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec59
jmp 0xead0
movl $0x250, %edi            # imm = 0x250
callq 0x32d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x3cb0
jmp 0xeb4d
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5760
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
cmpl $0x0, -0x14(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
leaq -0x58(%rbp), %rdi
callq 0xec70
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
xorl %eax, %eax
leaq -0x58(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0xeba0
leaq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x7560
movq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4e60
movq -0x20(%rbp), %rdi
callq 0x3fe0
movl $0x0, -0x5c(%rbp)
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x79(%rbp)
je 0xebe1
movl -0x5c(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xebea
jmp 0xec32
movq -0x20(%rbp), %rdi
callq 0x4a80
movl -0x14(%rbp), %ecx
movl $0x1, %edi
movl $0xf, %eax
cmpl $0x0, %ecx
cmovel %eax, %edi
callq 0x31d0
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xebca
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x250, %esi            # imm = 0x250
callq 0x32f0
jmp 0xec65
leaq -0x58(%rbp), %rdi
callq 0xece0
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0xec59
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34b0
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x10(%rax), %rdi
callq 0x6f40
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x7470
leaq -0x28(%rbp), %rdi
callq 0x8110
movl $0x0, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7be0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7cf0
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xef60
testb $0x1, %al
jne 0xed59
jmp 0xee2f
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xefa0
movq (%rax), %rdi
addq $0x48, %rdi
callq 0x3100
movq -0x88(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xefa0
movq (%rax), %rdi
addq $0xb8, %rdi
callq 0x3100
movq -0x88(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xefa0
movq (%rax), %rdi
addq $0xd8, %rdi
callq 0x3100
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xefa0
movq (%rax), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x3100
movl -0x7c(%rbp), %esi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
movq %rax, %r9
leaq 0x1901(%rip), %rdi      # 0x106fa
xorl %eax, %eax
callq 0x3040
jmp 0xee02
jmp 0xee04
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xefc0
movq %rax, -0x58(%rbp)
jmp 0xed36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7a60
jmp 0xee50
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f60
jmp 0xee3e
leaq -0x20(%rbp), %rdi
callq 0x7a60
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: brunokeymolen[P]ssdp/src/main.cpp
// Function: MainClass::SSDPMessage(SSDPParser*)
int SSDPMessage(SSDPParser *parsedmsg){
        switch(parsedmsg->GetType()){
            case SSDP_TYPE_HTTP:
                //printf("SSDP_TYPE_HTTP\n");
                break;
            case SSDP_TYPE_NOTIFY:
                //printf("SSDP_TYPE_NOTIFY\n");
                break;
            case SSDP_TYPE_MSEARCH:
                //printf("SSDP_TYPE_MSEARCH\n");
                break;
            default:
                //printf("unknown\n");
                break;
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xccb0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $0x1, %eax
je 0xeedb
jmp 0xeec5
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xeedd
jmp 0xeecf
movl -0x14(%rbp), %eax
subl $0x3, %eax
jne 0xeedf
jmp 0xeed9
jmp 0xeee1
jmp 0xeee1
jmp 0xeee1
jmp 0xeee1
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: brunokeymolen[P]ssdp/src/main.cpp
// Function: MainClass::SSDPDBMessage(SSDPDBMsg*)
int SSDPDBMessage(SSDPDBMsg* msg){
        //SSDPDB* db = UPNP::GetInstance()->GetSSDP()->GetDB();
        switch(msg->type){
            case SSDPDBMsg_DeviceUpdate:
            case SSDPDBMsg_ServiceUpdate:
                if (verbose_)
                {
                  dump_results();
                }
                break;
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
subl $0x1, %eax
ja 0xef2c
jmp 0xef17
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0xef2a
movq -0x18(%rbp), %rdi
callq 0xece0
jmp 0xef2c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x53a0
movq -0x90(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ba50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ba80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1bab0
testb $0x1, %al
jne 0x19037
jmp 0x190e4
leaq -0x28(%rbp), %rdi
callq 0x1baf0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x78(%rbp), %rdi
callq *%rax
jmp 0x1905a
leaq 0x2c93c(%rip), %rdx     # 0x4599d
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1bb10
jmp 0x19070
movq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5370
jmp 0x19082
leaq -0x58(%rbp), %rdi
callq 0x5518
leaq -0x78(%rbp), %rdi
callq 0x5518
leaq -0x28(%rbp), %rdi
callq 0x1bb60
jmp 0x19021
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1910a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x190d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5518
leaq -0x78(%rbp), %rdi
callq 0x5518
jmp 0x1910a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x190fa
movq -0xa0(%rbp), %rdi
callq 0x5518
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x5518
movq -0x80(%rbp), %rdi
callq 0x5490
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x54a0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x2c32b(%rip), %rsi     # 0x4599e
callq 0x134c0
jmp 0x1967a
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0x60(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x196fb
movq -0x60(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x196a5
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5370
jmp 0x196b4
leaq -0x48(%rbp), %rdi
callq 0x5518
jmp 0x196fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x19731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x19728
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5518
jmp 0x19728
movq -0x58(%rbp), %rdi
movl $0x3b, %esi
callq 0x5230
jmp 0x1970b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1971e
movq -0x58(%rbp), %rdi
callq 0x5518
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x48, %rdi
callq 0x1ba10
cmpq $0x0, %rax
jne 0x19ae2
leaq -0x11(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x54a0
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x2b8a1(%rip), %rsi     # 0x45354
callq 0x134c0
jmp 0x19aba
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x19c62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x52f0
jmp 0x19c72
movb $0x0, -0x25(%rbp)
leaq -0x26(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x54a0
movq -0xa0(%rbp), %rdi
movq -0xb0(%rbp), %rdx
leaq 0x2b852(%rip), %rsi     # 0x4535d
callq 0x134c0
jmp 0x19b12
leaq -0x26(%rbp), %rdi
callq 0x52f0
movq -0x90(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ba50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ba80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bab0
testb $0x1, %al
jne 0x19b5a
jmp 0x19c27
leaq -0x38(%rbp), %rdi
callq 0x1baf0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x19b80
leaq 0x2b7ef(%rip), %rdx     # 0x45376
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x19b99
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5370
jmp 0x19bab
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x38(%rbp), %rdi
callq 0x1bb60
jmp 0x19b44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x52f0
jmp 0x19c72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x19c54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x19c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x19c54
movq -0xa0(%rbp), %rdi
leaq 0x2b720(%rip), %rsi     # 0x45355
callq 0x5280
jmp 0x19c3c
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x19c52
movq -0xa0(%rbp), %rdi
callq 0x5518
jmp 0x19c62
movq -0xa0(%rbp), %rdi
callq 0x5518
jmp 0x19c72
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
movb $0x0, -0x11(%rbp)
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq *%rax
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
leaq 0x2b0a3(%rip), %rdx     # 0x4536e
callq 0x1bb10
jmp 0x1a2d2
leaq -0x38(%rbp), %rdi
callq 0x5518
movq -0xe0(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1be30
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1be60
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1be90
testb $0x1, %al
jne 0x1a31a
jmp 0x1a3f9
leaq -0x58(%rbp), %rdi
callq 0x1bed0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xa8(%rbp), %rdi
callq *%rax
jmp 0x1a340
leaq 0x2b02e(%rip), %rdx     # 0x45375
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb10
jmp 0x1a35c
movq -0xd8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5370
jmp 0x1a371
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
leaq -0x58(%rbp), %rdi
callq 0x1bef0
jmp 0x1a304
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5518
jmp 0x1a4dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1a4d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1a3e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
jmp 0x1a4d1
movq -0xe0(%rbp), %rdi
addq $0x48, %rdi
callq 0x1bf10
cmpq $0x0, %rax
je 0x1a427
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
leaq 0x2af3c(%rip), %rsi     # 0x45371
callq 0x5280
jmp 0x1a43c
movq -0xe0(%rbp), %rax
movq 0x60(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xc8(%rbp), %rdi
callq *%rax
jmp 0x1a459
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x5370
jmp 0x1a46e
leaq -0xc8(%rbp), %rdi
callq 0x5518
movq -0xd8(%rbp), %rdi
leaq 0x2aecd(%rip), %rsi     # 0x45355
callq 0x5280
jmp 0x1a48f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1a4c1
jmp 0x1a4b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x5518
jmp 0x1a4d1
movq -0xd8(%rbp), %rdi
callq 0x5518
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x5518
movq -0x40(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x11(%rbp)
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq *%rax
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq 0x2ae1e(%rip), %rdx     # 0x4536e
callq 0x1bb10
jmp 0x1a557
leaq -0x38(%rbp), %rdi
callq 0x5518
movq -0xc0(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1a59f
jmp 0x1a67b
leaq -0x58(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xa8(%rbp), %rdi
callq *%rax
jmp 0x1a5c5
leaq 0x2ada9(%rip), %rdx     # 0x45375
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb10
jmp 0x1a5e1
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5370
jmp 0x1a5f6
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
leaq -0x58(%rbp), %rdi
callq 0x1bff0
jmp 0x1a589
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5518
jmp 0x1a6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1a6e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1a66d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0xa8(%rbp), %rdi
callq 0x5518
jmp 0x1a6e2
movq -0xc0(%rbp), %rdi
addq $0x50, %rdi
callq 0x1c010
cmpq $0x0, %rax
je 0x1a6a9
movq -0xb8(%rbp), %rdi
callq 0x5330
movq -0xb8(%rbp), %rdi
callq 0x5330
movq -0xb8(%rbp), %rdi
movl $0x29, %esi
callq 0x5230
jmp 0x1a6bc
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1a6d2
movq -0xb8(%rbp), %rdi
callq 0x5518
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x5518
movq -0x40(%rbp), %rdi
callq 0x5490
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x54a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x2a8ef(%rip), %rsi     # 0x45047
callq 0x134c0
jmp 0x1a75f
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0xa0(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1a7a7
jmp 0x1a877
leaq -0x38(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x1a7cd
leaq 0x2aba1(%rip), %rdx     # 0x45375
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x1a7e6
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5370
jmp 0x1a7f8
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x38(%rbp), %rdi
callq 0x1bff0
jmp 0x1a791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x1a8ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1a8de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1a869
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x1a8de
movq -0xa0(%rbp), %rdi
addq $0x48, %rdi
callq 0x1c010
cmpq $0x0, %rax
je 0x1a8a5
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
movl $0x5d, %esi
callq 0x5230
jmp 0x1a8b8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1a8ce
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x54a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x2a614(%rip), %rsi     # 0x4537c
callq 0x134c0
jmp 0x1ad6f
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0xa0(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1adb7
jmp 0x1ae87
leaq -0x38(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x1addd
leaq 0x2a591(%rip), %rdx     # 0x45375
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x1adf6
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5370
jmp 0x1ae08
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x38(%rbp), %rdi
callq 0x1bff0
jmp 0x1ada1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x1aefa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1aeee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1ae79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x1aeee
movq -0xa0(%rbp), %rdi
addq $0x48, %rdi
callq 0x1c010
cmpq $0x0, %rax
je 0x1aeb5
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
movl $0x7d, %esi
callq 0x5230
jmp 0x1aec8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1aede
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x54a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x2a420(%rip), %rsi     # 0x45388
callq 0x134c0
jmp 0x1af6f
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0xa0(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1afb7
jmp 0x1b087
leaq -0x38(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x1afdd
leaq 0x2a391(%rip), %rdx     # 0x45375
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x1aff6
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5370
jmp 0x1b008
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x38(%rbp), %rdi
callq 0x1bff0
jmp 0x1afa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x1b0fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1b0ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1b079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x1b0ee
movq -0xa0(%rbp), %rdi
addq $0x48, %rdi
callq 0x1c010
cmpq $0x0, %rax
je 0x1b0b5
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
movl $0x7d, %esi
callq 0x5230
jmp 0x1b0c8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1b0de
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x54a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x2a034(%rip), %rsi     # 0x4539c
callq 0x134c0
jmp 0x1b36f
leaq -0x12(%rbp), %rdi
callq 0x52f0
movq -0xa0(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1b3b7
jmp 0x1b487
leaq -0x38(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0x1b3dd
leaq 0x29f91(%rip), %rdx     # 0x45375
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1bb10
jmp 0x1b3f6
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5370
jmp 0x1b408
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
leaq -0x38(%rbp), %rdi
callq 0x1bff0
jmp 0x1b3a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x52f0
jmp 0x1b4fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1b4ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1b479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5518
leaq -0x88(%rbp), %rdi
callq 0x5518
jmp 0x1b4ee
movq -0xa0(%rbp), %rdi
addq $0x48, %rdi
callq 0x1c010
cmpq $0x0, %rax
je 0x1b4b5
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
callq 0x5330
movq -0x98(%rbp), %rdi
movl $0x7d, %esi
callq 0x5230
jmp 0x1b4c8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1b4de
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5518
movq -0x20(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/ast.cpp
// Function: MaxHeapLiteral::getStringRepr[abi:cxx11]()
std::string MaxHeapLiteral::getStringRepr()
{
	if (elements.empty())
		return "max_heap <" + type + "> {}";

	std::string res = "max_heap <" + type + "> {";

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

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

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x68, %rdi
callq 0x1c130
testb $0x1, %al
jne 0x1b54e
jmp 0x1b5b4
movq -0xc8(%rbp), %rdx
addq $0x48, %rdx
leaq 0x29e46(%rip), %rsi     # 0x453a6
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1bc80
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
leaq 0x29e2c(%rip), %rdx     # 0x453b1
callq 0x1bb10
jmp 0x1b58c
leaq -0x30(%rbp), %rdi
callq 0x5518
jmp 0x1b768
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
jmp 0x1b778
movq -0xc8(%rbp), %rdx
movb $0x0, -0x3d(%rbp)
addq $0x48, %rdx
leaq 0x29ddc(%rip), %rsi     # 0x453a6
leaq -0x60(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1bc80
movq -0xd8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
leaq 0x29da9(%rip), %rdx     # 0x45398
callq 0x1bb10
jmp 0x1b5f6
leaq -0x60(%rbp), %rdi
callq 0x5518
movq -0xc8(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1b63e
jmp 0x1b717
leaq -0x70(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xc0(%rbp), %rdi
callq *%rax
jmp 0x1b664
leaq 0x29d0a(%rip), %rdx     # 0x45375
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1bb10
jmp 0x1b680
movq -0xd8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5370
jmp 0x1b695
leaq -0xa0(%rbp), %rdi
callq 0x5518
leaq -0xc0(%rbp), %rdi
callq 0x5518
leaq -0x70(%rbp), %rdi
callq 0x1bff0
jmp 0x1b628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5518
jmp 0x1b778
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1b75a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1b709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5518
leaq -0xc0(%rbp), %rdi
callq 0x5518
jmp 0x1b75a
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
movl $0x7d, %esi
callq 0x5230
jmp 0x1b742
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x1b758
movq -0xd8(%rbp), %rdi
callq 0x5518
jmp 0x1b768
movq -0xd8(%rbp), %rdi
callq 0x5518
jmp 0x1b778
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/ast.cpp
// Function: MinHeapLiteral::getStringRepr[abi:cxx11]()
std::string MinHeapLiteral::getStringRepr()
{
	if (elements.empty())
		return "min_heap <" + type + "> {}";

	std::string res = "min_heap <" + type + "> {";

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

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

	res.push_back('}');

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x68, %rdi
callq 0x1c130
testb $0x1, %al
jne 0x1b7ce
jmp 0x1b834
movq -0xc8(%rbp), %rdx
addq $0x48, %rdx
leaq 0x29bd6(%rip), %rsi     # 0x453b6
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1bc80
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
leaq 0x29bac(%rip), %rdx     # 0x453b1
callq 0x1bb10
jmp 0x1b80c
leaq -0x30(%rbp), %rdi
callq 0x5518
jmp 0x1b9e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5518
jmp 0x1b9f8
movq -0xc8(%rbp), %rdx
movb $0x0, -0x3d(%rbp)
addq $0x48, %rdx
leaq 0x29b6c(%rip), %rsi     # 0x453b6
leaq -0x60(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1bc80
movq -0xd8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
leaq 0x29b29(%rip), %rdx     # 0x45398
callq 0x1bb10
jmp 0x1b876
leaq -0x60(%rbp), %rdi
callq 0x5518
movq -0xc8(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1bf60
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1bf90
testb $0x1, %al
jne 0x1b8be
jmp 0x1b997
leaq -0x70(%rbp), %rdi
callq 0x1bfd0
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0xc0(%rbp), %rdi
callq *%rax
jmp 0x1b8e4
leaq 0x29a8a(%rip), %rdx     # 0x45375
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1bb10
jmp 0x1b900
movq -0xd8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5370
jmp 0x1b915
leaq -0xa0(%rbp), %rdi
callq 0x5518
leaq -0xc0(%rbp), %rdi
callq 0x5518
leaq -0x70(%rbp), %rdi
callq 0x1bff0
jmp 0x1b8a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5518
jmp 0x1b9f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1b9da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1b989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5518
leaq -0xc0(%rbp), %rdi
callq 0x5518
jmp 0x1b9da
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
callq 0x5330
movq -0xd8(%rbp), %rdi
movl $0x7d, %esi
callq 0x5230
jmp 0x1b9c2
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x1b9d8
movq -0xd8(%rbp), %rdi
callq 0x5518
jmp 0x1b9e8
movq -0xd8(%rbp), %rdi
callq 0x5518
jmp 0x1b9f8
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x68, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x60(%rdi)
callq 0x235f0
jmp 0x1f885
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x5050
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x68, %esi
callq 0x52b0
movq -0x18(%rbp), %rdi
callq 0x5490
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x70, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x233f0
jmp 0x1f941
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x5050
movq -0x38(%rbp), %rdi
callq 0x1f390
movq -0x38(%rbp), %rdi
movl $0x5, %esi
callq 0x21d60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x70, %esi
callq 0x52b0
movq -0x18(%rbp), %rdi
callq 0x5490
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x50, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23590
jmp 0x1fa15
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
leaq 0x4629f(%rip), %rsi     # 0x65ce0
callq 0x16920
movb %al, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x48(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x50, %esi
callq 0x52b0
movq -0x18(%rbp), %rdi
callq 0x5490
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x60, %edi
callq 0x52a0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x23660
jmp 0x1facd
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x30, %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x22d00
movq -0x40(%rbp), %rdi
leaq 0x4612b(%rip), %rsi     # 0x65c20
callq 0x21d00
testb $0x1, %al
jne 0x1fb42
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x1fb16
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1fc5c
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x52b0
jmp 0x1fc66
movq -0x40(%rbp), %rdi
callq 0x1f390
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x21d60
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
leaq 0x460d4(%rip), %rsi     # 0x65c40
callq 0x21d00
testb $0x1, %al
jne 0x1fb9a
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1fb8d
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1fc5c
movq -0x40(%rbp), %rdi
leaq 0x460bb(%rip), %rsi     # 0x65c60
callq 0x21d00
testb $0x1, %al
jne 0x1fbd3
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1fbc6
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1fc5c
movq -0x40(%rbp), %rdi
callq 0x225c0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x70, %rdi
leaq 0x4616a(%rip), %rsi     # 0x65d60
callq 0x16920
testb $0x1, %al
jne 0x1fc01
jmp 0x1fc54
movq -0x40(%rbp), %rdi
callq 0x1f390
movq -0x40(%rbp), %rdi
leaq 0x4604b(%rip), %rsi     # 0x65c60
callq 0x21d00
testb $0x1, %al
jne 0x1fc40
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1fc36
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1fc5c
movq -0x40(%rbp), %rdi
callq 0x225c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5490
nop