LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/slafi[P]EventSystem/EventSystem/src/utils.cpp
// Function: Events::format_timestamp[abi:cxx11]()
std::string format_timestamp()
	{
		time_t rawtime;
		struct tm * timeInfo;
		char buffer[80];

		time(&rawtime);
		timeInfo = localtime(&rawtime);

		strftime(buffer, sizeof(buffer), "%d-%m-%Y %H:%M:%S", timeInfo);
		std::string str(buffer);

		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2120
leaq 0x1327(%rip), %rdx      # 0x52ca
leaq -0x70(%rbp), %r14
movl $0x50, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x2140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2090
leaq (%rax,%rbp), %rdx
addq $-0x70, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f86
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, Expr*)
void print(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, "%s", e->value);
    if (e->next) {
        fprintf(fp, ", ");
        print(fp, e->next);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x6045
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xfbaa(%rip), %r15      # 0x15bb4
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x31d0
cmpq $0x0, 0x10(%rbx)
je 0x603b
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3370
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x600a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, TypeQual*)
void print(FILE* fp, TypeQual* q)
{
    if (!q)
        return;
    if (q->qual == 'a') {
        fprintf(fp, "[");
        print(fp, q->args);
        fprintf(fp, "]");
    } else
        fprintf(fp, "%c", q->qual);
}

// Assembly:
testq %rsi, %rsi
je 0x608a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rsi), %edi
cmpl $0x61, %edi
jne 0x607e
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x3230
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x5fee
movl $0x5d, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print_args(_IO_FILE*, Var*)
void print_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    print_devicespec(fp, v);
    print_iospec(fp, v);
    print_var(fp, v);
    if (v->next) {
        fprintf(fp, ", ");
        print_args(fp, v->next);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x61ad
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x79b1(%rip), %r15      # 0xdaf9
leaq 0xfa65(%rip), %r12      # 0x15bb4
cmpb $0x67, 0x9(%rbx)
jne 0x616a
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3370
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60b1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60ed
cmpq $0x0, 0x30(%rbx)
je 0x61a5
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x3370
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x614f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, Func*)
void print(FILE* fp, Func* f)
{
    if (!f)
        return;
    if (f->ret) {
        print_var(fp, f->ret);
        fprintf(fp, " = ");
    }
    if (f->thisv)
        fprintf(fp, "%s->%s.", f->thisv, f->classv);
    fprintf(fp, "%s(", f->funcv);
    print_args(fp, f->args);
    fprintf(fp, ");\n");
}

// Assembly:
testq %rsi, %rsi
je 0x624a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x61ee
movq %rbx, %rdi
callq 0x60ed
leaq 0xf833(%rip), %rdi      # 0x15a0f
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x620c
movq 0x38(%r14), %rcx
leaq 0x790b(%rip), %rsi      # 0xdb0d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %rdx
leaq 0xf78d(%rip), %rsi      # 0x159a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x612b
leaq 0x106c7(%rip), %rdi     # 0x168fb
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3370
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](TypeQual*)
string id_string(TypeQual* q)
{
    if (!q)
        return "";
    if (q->qual == 'a')
        return "[" + id_string(q->args) + "]";
    else
        return (string() + q->qual);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6390
movb (%rsi), %al
cmpb $0x61, %al
jne 0x63ae
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x624b
leaq 0x779b(%rip), %rcx      # 0xdaf5
movl $0x1, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x31e0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x63fa
movq %rdx, -0x30(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x20(%rbp)
jmp 0x6401
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xdeb9(%rip), %rdx      # 0x14257
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6bde
jmp 0x64c1
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movsbl %al, %r8d
leaq -0x30(%rbp), %rdi
movl $0x1, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3340
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x644a
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x6450
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq -0x30(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x76d4(%rip), %rsi      # 0xdaf7
callq 0x3360
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x6476
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x647c
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x64c1
movq -0x20(%rbp), %rsi
jmp 0x64b9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x64a8
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64c1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x64fc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3180
jmp 0x64fc
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x6515
movq -0x20(%rbp), %rsi
jmp 0x650d
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6515
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](Var*)
string id_string(Var* v)
{
    if (!v)
        return "";

    string name;
    if (v->devicespec == 'c')
        name += "c ";
    else if (v->devicespec == 'g')
        name += "g ";

    if (v->iospec == 'i')
        name += "i ";
    else if (v->iospec == 'o')
        name += "o ";
    else
        name += "io ";
    name += promote_int(v->basetype);
    name += id_string(v->qual);
    if (v->tinfo == VT_const) {
        name += " ";
        name += v->name;
    }
    if (v->next) {
        name += ", ";
        name += id_string(v->next);
    }
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
testq %rsi, %rsi
je 0x6561
movq %rsi, %r14
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl 0x9(%rsi), %eax
cmpl $0x67, %eax
je 0x6578
cmpl $0x63, %eax
jne 0x6587
leaq 0x75b6(%rip), %rsi      # 0xdb15
jmp 0x657f
leaq 0xdcef(%rip), %rdx      # 0x14257
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6bde
jmp 0x6669
leaq 0x7599(%rip), %rsi      # 0xdb18
movq %rbx, %rdi
callq 0x3360
movb 0x8(%r14), %al
cmpb $0x6f, %al
leaq 0x758b(%rip), %rcx      # 0xdb1f
leaq 0x7583(%rip), %rdx      # 0xdb1e
cmoveq %rcx, %rdx
cmpb $0x69, %al
leaq 0x7573(%rip), %rsi      # 0xdb1b
cmovneq %rdx, %rsi
movq %rbx, %rdi
callq 0x3360
movq 0x10(%r14), %rdi
callq 0x58e4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3360
movq 0x18(%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x632a
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x65ff
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3180
cmpl $0x13, 0x20(%r14)
jne 0x6621
leaq 0xf367(%rip), %rsi      # 0x15974
movq %rbx, %rdi
callq 0x3360
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3360
cmpq $0x0, 0x30(%r14)
je 0x6669
leaq 0xf585(%rip), %rsi      # 0x15bb4
movq %rbx, %rdi
callq 0x3360
movq 0x30(%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x651d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6669
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
jne 0x6699
jmp 0x66ac
jmp 0x66a9
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66ac
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3180
jmp 0x66ac
jmp 0x66a9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x66bf
movq (%r15), %rsi
incq %rsi
callq 0x3180
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](Func*)
string id_string(Func* f)
{
    if (!f)
        return "";

    string name;
    if (f->ret) {
        name += id_string(f->ret);
        name += " = ";
    }
    if (f->thisv) {
        name += f->thisv;
        name += "->";
        name += f->classv;
        name += ".";
    }
    name += f->funcv;
    name += "(";
    name += id_string(f->args);
    name += ")";
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
testq %rsi, %rsi
je 0x67dd
movq %rsi, %r14
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x6740
leaq -0x38(%rbp), %rdi
callq 0x651d
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6731
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3180
leaq 0xf2d7(%rip), %rsi      # 0x15a0f
movq %rbx, %rdi
callq 0x3360
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x677b
movq %rbx, %rdi
callq 0x3360
leaq 0xf1a1(%rip), %rsi      # 0x158f9
movq %rbx, %rdi
callq 0x3360
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3360
leaq 0x73a0(%rip), %rsi      # 0xdb13
movq %rbx, %rdi
callq 0x3360
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x3360
leaq 0xf2b8(%rip), %rsi      # 0x15a46
movq %rbx, %rdi
callq 0x3360
movq 0x48(%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x651d
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67cc
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3180
leaq 0x10f3d(%rip), %rsi     # 0x17710
movq %rbx, %rdi
callq 0x3360
jmp 0x67ef
leaq 0xda73(%rip), %rdx      # 0x14257
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6bde
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6801
jmp 0x6821
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6824
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3180
jmp 0x6824
jmp 0x6821
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6837
movq (%r15), %rsi
incq %rsi
callq 0x3180
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Expr*)
void destroy(Expr* e)
{
    if (!e)
        return;
    destroy(e->next);
    delete[] e->value;
    delete e;
}

// Assembly:
testq %rdi, %rdi
je 0x6877
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x683f
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6864
callq 0x3240
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3180
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Var*)
void destroy(Var* v)
{
    if (!v) 
        return;
    destroy(v->next);
    destroy(v->qual);
    delete[] v->basetype;
    delete[] v->name;
    delete v;
}

// Assembly:
testq %rdi, %rdi
je 0x68f2
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x68a3
movq 0x18(%rbx), %rdi
callq 0x6878
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x68d1
callq 0x3240
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x68df
callq 0x3240
movl $0x38, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3180
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Func*)
void destroy(Func* f)
{
    while (f) {
        Func* oldf = f;
        f = f->next;

        destroy(oldf->same_next);
        destroy(oldf->ret);
        if (oldf->thisv)
            delete[] oldf->thisv;
        if (oldf->classv)
            delete[] oldf->classv;
        delete[] oldf->funcv;
        destroy(oldf->args);
        delete oldf;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x697f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rbx), %r14
movq 0x60(%rbx), %rdi
callq 0x68f3
movq 0x50(%rbx), %rdi
callq 0x68a3
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x692a
callq 0x3240
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6938
callq 0x3240
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x6946
callq 0x3240
movq 0x48(%rbx), %rdi
callq 0x68a3
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x6966
movq (%rax), %rsi
incq %rsi
callq 0x3180
movl $0x68, %esi
movq %rbx, %rdi
callq 0x3180
movq %r14, %rbx
testq %r14, %r14
jne 0x6906
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy_inherits()
void destroy_inherits()
{
    map<string,InheritsDecl*>::iterator i = class_decls.begin();
    for (; i != class_decls.end(); ++i) {
        destroy(i->second);
        i->second = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x15aa7(%rip), %rbx     # 0x1c460
leaq 0x15a90(%rip), %r14     # 0x1c450
cmpq %r14, %rbx
je 0x69e6
movq 0x40(%rbx), %rdi
callq 0x6980
movq $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x3110
movq %rax, %rbx
cmpq %r14, %rax
jne 0x69c5
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_dim_args(Expr*, int&)
void label_dim_args(Expr* e, int& icount)
{
    if (!e)
        return;
    e->input_label = icount++;
    label_dim_args(e->next, icount);
}

// Assembly:
testq %rdi, %rdi
je 0x7224
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rsi)
movl %eax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x7211
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_dim_args(Var*, int&)
void label_dim_args(Var* v, int& icount)
{
    if (!v)
        return;
    if (v->qual)
        label_dim_args(v->qual->args, icount);
    label_dim_args(v->next, icount);
}

// Assembly:
testq %rdi, %rdi
je 0x7259
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x724f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x724f
movl (%rsi), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rsi)
movl %ecx, (%rax)
movq 0x10(%rax), %rax
jmp 0x723b
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x722e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_args(Var*, int&, int&)
void label_args(Var* v, int& icount, int& ocount)
{
    if (!v)
        return;
    if (v->iospec == 'i' || v->iospec == 'b')
        v->input_label = icount++;
    if (v->iospec == 'o' || v->iospec == 'b')
        v->output_label = ocount++;
    label_args(v->next, icount, ocount);
}

// Assembly:
testq %rdi, %rdi
je 0x7299
pushq %rbp
movq %rsp, %rbp
movzbl 0x8(%rdi), %eax
cmpl $0x62, %eax
je 0x7276
cmpl $0x6f, %eax
je 0x7285
cmpl $0x69, %eax
jne 0x728f
movl (%rsi), %ecx
leal 0x1(%rcx), %r8d
movl %r8d, (%rsi)
movl %ecx, (%rdi)
cmpb $0x62, %al
jne 0x728f
movl (%rdx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdx)
movl %eax, 0x4(%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x7263
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_args(Func*)
void label_args(Func* f)
{
    int icount = 0;
    int ocount = 0;
    if (f->thisv)
        icount = 1;
    label_args(f->ret, icount, ocount);
    label_args(f->args, icount, ocount);
    label_dim_args(f->ret, icount);
    label_dim_args(f->args, icount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
movl %eax, -0x20(%rbp)
cmpq $0x0, 0x30(%rdi)
je 0x72bd
movl $0x1, -0x1c(%rbp)
movq 0x50(%rbx), %rdi
leaq -0x1c(%rbp), %r14
leaq -0x20(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x725a
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x725a
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x7317
movl -0x1c(%rbp), %ecx
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x730b
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x730b
movl %ecx, (%rdx)
incl %ecx
movq 0x10(%rdx), %rdx
jmp 0x72fc
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0x72ef
movl %ecx, -0x1c(%rbp)
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x7348
movl -0x1c(%rbp), %ecx
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x733f
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x733f
movl %ecx, (%rdx)
incl %ecx
movq 0x10(%rdx), %rdx
jmp 0x7330
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0x7323
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: fortranize_args(Var*, int)
int fortranize_args(Var* v, int line)
{
    if (!v)
        return 0;
    int errcount = 0;
    if (v->tinfo == VT_obj || v->tinfo == VT_p_obj || v->tinfo == VT_r_obj) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Cannot pass object %s to FORTRAN\n", v->name);
        ++errcount;
    } else if (v->tinfo == VT_rarray) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Cannot pass pointer ref %s to FORTRAN\n", v->name);
        ++errcount;
    } else if (v->tinfo == VT_string) {
        fprintf(stderr, "Warning (%d): ", line);
        fprintf(stderr, "Danger passing C string %s to FORTRAN\n", v->name);
    } else if (v->tinfo == VT_scalar || v->tinfo == VT_r_scalar) {
        v->tinfo = VT_p_scalar;
    } else if (v->tinfo == VT_cscalar || v->tinfo == VT_r_cscalar) {
        v->tinfo = VT_p_cscalar;
    } else if (v->tinfo == VT_zscalar || v->tinfo == VT_r_zscalar) {
        v->tinfo = VT_p_zscalar;
    }
    return errcount + fortranize_args(v->next, line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x73e2
movl %esi, %ebx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x67b2(%rip), %r12      # 0xdb24
movl 0x20(%r15), %ecx
decl %ecx
movl $0x0, %eax
cmpl $0x11, %ecx
ja 0x73ab
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
xorl %eax, %eax
jmpq *%rcx
movl $0xc, 0x20(%r15)
jmp 0x73a9
movl $0xe, 0x20(%r15)
jmp 0x73a9
movl $0xd, 0x20(%r15)
xorl %eax, %eax
addl %eax, %r14d
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x7372
jmp 0x73e5
movl %ebx, %edi
movq %r15, %rsi
callq 0x3508
jmp 0x73cf
movl %ebx, %edi
movq %r15, %rsi
callq 0x34cb
movl $0x1, %eax
jmp 0x73ab
movl %ebx, %edi
movq %r15, %rsi
callq 0x348e
jmp 0x73a9
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: fortranize_ret(Var*, int)
int fortranize_ret(Var* v, int line)
{
    if (!v)
        return 0;
    if (v->tinfo == VT_cscalar || v->tinfo == VT_zscalar) {
        fprintf(stderr, "Warning (%d): ", line);
        fprintf(stderr, "Danger returning complex from FORTRAN\n");
    } else if (v->tinfo != VT_scalar) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Can only return scalars from FORTRAN\n");
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7406
movl 0x20(%rdi), %eax
cmpl $0x6, %eax
jne 0x740f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addl $-0x7, %eax
movl %esi, %edi
cmpl $0x1, %eax
ja 0x7420
callq 0x3545
jmp 0x7406
callq 0x3580
movl $0x1, %ebx
jmp 0x7406
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: fortranize_args(Func*, int)
int fortranize_args(Func* f, int line)
{
    if (!f->fort)
        return 0;
    return (fortranize_args(f->args, line) +
            fortranize_ret(f->ret, line));
}

// Assembly:
xorl %eax, %eax
cmpb $0x1, 0x24(%rdi)
jne 0x7467
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x7353
movl %eax, %r15d
movq 0x50(%r14), %rdi
movl %ebx, %esi
callq 0x73f1
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: assign_scalar_tinfo(Var*, int, int, int, int, int, int)
int assign_scalar_tinfo(Var* v, int line,
                        int tags, int tagp, int tagr, int taga,
                        int tagar)
{
    // Numeric types
    if (!v->qual) {
        v->tinfo = tags;
    } else if (v->qual->qual == '*') {
        v->tinfo = tagp;
    } else if (v->qual->qual == '&') {
        v->tinfo = tagr;
    } else if (v->qual->qual == 'a') {
        v->tinfo = taga;
        if (v->qual->args && 
            v->qual->args->next && 
            v->qual->args->next->next) {
            fprintf(stderr, "Error (%d): ", line);
            fprintf(stderr, "Array %s should be 1D or 2D\n", v->name);
            return 1;
        }
    } else if (v->qual->qual == 'r') {
        v->tinfo = tagar;
        if (tagar == VT_unk) {
            fprintf(stderr, "Error (%d): ", line);
            fprintf(stderr, "Array ref %s must be to a real array\n", 
                    v->name);
            return 1;
        }
        if (v->qual->args && 
            v->qual->args->next && 
            v->qual->args->next->next) {
            fprintf(stderr, "Error (%d): ", line);
            fprintf(stderr, "Array %s should be 1D or 2D\n", v->name);
            return 1;
        }
    } else {
        assert(0);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %r10
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x7494
movzbl (%rax), %edx
cmpl $0x60, %edx
jg 0x749a
cmpl $0x26, %edx
je 0x74d6
cmpl $0x2a, %edx
jne 0x751a
movl %ecx, 0x20(%r10)
jmp 0x74da
movl %edx, 0x20(%r10)
jmp 0x74da
cmpl $0x61, %edx
je 0x74de
cmpl $0x72, %edx
jne 0x751a
movl 0x10(%rbp), %ecx
movl %ecx, 0x20(%r10)
testl %ecx, %ecx
je 0x7509
movq 0x8(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x74dc
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x74dc
cmpq $0x0, 0x10(%rcx)
je 0x74dc
movl %esi, %edi
movq %r10, %rsi
callq 0x35bb
jmp 0x7513
movl %r8d, 0x20(%r10)
xorl %eax, %eax
popq %rbp
retq
movl %r9d, 0x20(%r10)
movq 0x8(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x74dc
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x74dc
cmpq $0x0, 0x10(%rcx)
je 0x74dc
movl %esi, %edi
movq %r10, %rsi
callq 0x3635
jmp 0x7513
movl %esi, %edi
movq %r10, %rsi
callq 0x35f8
movl $0x1, %eax
jmp 0x74dc
leaq 0x6a15(%rip), %rdi      # 0xdf36
leaq 0x6760(%rip), %rsi      # 0xdc88
leaq 0x676c(%rip), %rcx      # 0xdc9b
movl $0xb3, %edx
callq 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: typecheck_return(Var*, int)
int typecheck_return(Var* v, int line)
{
    if (!v)
        return 0;

    int err = assign_tinfo(v, line);
    if ((v->tinfo == VT_array ||
         v->tinfo == VT_carray ||
         v->tinfo == VT_zarray) && 
        !(v->qual && v->qual->args)) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Return array %s must have dims\n", v->name);
        ++err;
    } else if (v->tinfo == VT_const) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Cannot return constant\n");
        ++err;
    } else if (v->tinfo == VT_rarray) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Ref to array %s looks just like array on return\n", 
                v->name);
        ++err;
    } else if (v->tinfo == VT_string && v->qual) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Return string %s cannot have dims\n", v->name);
        ++err;
    }
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x780c
movl %esi, %r14d
movq %rdi, %r15
callq 0x7539
movl %eax, %ebx
movl 0x20(%r15), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
ja 0x77bc
movq 0x18(%r15), %rcx
testq %rcx, %rcx
je 0x784b
cmpq $0x0, 0x8(%rcx)
je 0x784b
cmpl $0x9, %eax
je 0x7813
cmpl $0x5, %eax
je 0x7878
cmpl $0x13, %eax
jne 0x78ac
movq 0x147fe(%rip), %r15     # 0x1bfd8
movq (%r15), %rdi
leaq 0x6388(%rip), %rsi      # 0xdb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r15), %rcx
leaq 0x65d1(%rip), %rdi      # 0xddc9
movl $0x17, %esi
movl $0x1, %edx
callq 0x3370
jmp 0x78aa
xorl %ebx, %ebx
jmp 0x78ac
cmpq $0x0, 0x18(%r15)
je 0x78ac
movq 0x147b3(%rip), %r12     # 0x1bfd8
movq (%r12), %rdi
leaq 0x633c(%rip), %rsi      # 0xdb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x65c9(%rip), %rsi      # 0xde12
jmp 0x78a3
movq 0x14786(%rip), %r12     # 0x1bfd8
movq (%r12), %rdi
leaq 0x630f(%rip), %rsi      # 0xdb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x6533(%rip), %rsi      # 0xdda9
jmp 0x78a3
movq 0x14759(%rip), %r12     # 0x1bfd8
movq (%r12), %rdi
leaq 0x62e2(%rip), %rsi      # 0xdb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x653e(%rip), %rsi      # 0xdde1
xorl %eax, %eax
callq 0x3270
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: typecheck(Func*, int)
int typecheck(Func* f, int line)
{
    label_args(f);
    return (typecheck_return(f->ret, line) + 
            typecheck_args(f->args, line) +
            fortranize_args(f, line));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x729a
movq 0x50(%r14), %rdi
movl %ebx, %esi
callq 0x7777
movl %eax, %r15d
movq 0x48(%r14), %rdi
movl %ebx, %esi
callq 0x78b7
movl %eax, %r12d
addl %r15d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x742c
addl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: has_output_args(Var*)
int has_output_args(Var* v)
{
    if (!v)
        return 0;
    if (v->iospec == 'o' || v->iospec == 'b')
        return 1;
    else 
        return has_output_args(v->next);
}

// Assembly:
testq %rdi, %rdi
je 0x7af5
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
movzbl 0x8(%rdi), %ecx
cmpl $0x62, %ecx
je 0x7af3
cmpl $0x6f, %ecx
je 0x7af3
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x7ada
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_output_args(_IO_FILE*, Var*, int&)
void print_output_args(FILE* fp, Var* v, int& first)
{
    if (!v)
        return;
    if (v->iospec == 'o' || v->iospec == 'b') {
        if (!first)
            fprintf(fp, ", ");
        fprintf(fp, "%s", v->name);
        first = 0;
    }
    print_output_args(fp, v->next, first);
}

// Assembly:
testq %rsi, %rsi
je 0x7b64
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe09c(%rip), %r12      # 0x15bb4
movzbl 0x8(%r14), %eax
cmpl $0x6f, %eax
je 0x7b27
cmpl $0x62, %eax
jne 0x7b53
cmpl $0x0, (%rbx)
jne 0x7b41
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x3370
movq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x31d0
movl $0x0, (%rbx)
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x7b18
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_input_args(_IO_FILE*, Var*)
void print_input_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->tinfo == VT_const)
        fprintf(fp, ", 0");
    else if (v->iospec == 'i' || v->iospec == 'b')
        fprintf(fp, ", %s", v->name);
    print_input_args(fp, v->next);
}

// Assembly:
testq %rsi, %rsi
je 0x7bd6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x63b2(%rip), %r15      # 0xdf34
leaq 0x63af(%rip), %r12      # 0xdf38
cmpl $0x13, 0x20(%rbx)
jne 0x7ba6
movl $0x3, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3370
jmp 0x7bc5
movzbl 0x8(%rbx), %eax
cmpl $0x69, %eax
je 0x7bb4
cmpl $0x62, %eax
jne 0x7bc5
movq 0x28(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x7b89
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_dimension_args(_IO_FILE*, Expr*)
void print_dimension_args(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, ", %s", e->value);
    print_dimension_args(fp, e->next);
}

// Assembly:
testq %rsi, %rsi
je 0x7c17
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6345(%rip), %r15      # 0xdf38
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x7bf3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_dimension_args(_IO_FILE*, Var*)
void print_dimension_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->qual)
        print_dimension_args(fp, v->qual->args);
    print_dimension_args(fp, v->next);
}

// Assembly:
testq %rsi, %rsi
je 0x7c71
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6303(%rip), %r15      # 0xdf38
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x7c60
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x7c60
movq 0x8(%r12), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x10(%r12), %r12
jmp 0x7c42
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x7c35
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_matlab_call(_IO_FILE*, Func*, char const*)
void print_matlab_call(FILE* fp, Func* f, const char* mexfunc)
{
    fprintf(fp, "mex_id_ = '%s';\n", id_string(f).c_str());
    if (f->ret || has_output_args(f->args)) {
        int first = 1;
        fprintf(fp, "[");
        print_output_args(fp, f->ret, first);
        print_output_args(fp, f->args, first);
        fprintf(fp, "] = ");
    }
    fprintf(fp, "%s(mex_id_", mexfunc);
    if (f->thisv)
        fprintf(fp, ", %s", f->thisv);
    print_input_args(fp, f->args);
    print_dimension_args(fp, f->ret);
    print_dimension_args(fp, f->args);
    fprintf(fp, ");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x66c7
movq (%r12), %rdx
leaq 0x629c(%rip), %rsi      # 0xdf3d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x7cc4
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3180
cmpq $0x0, 0x50(%r14)
je 0x7d97
leaq -0x40(%rbp), %r12
movl $0x1, (%r12)
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x3230
movq 0x50(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7af8
movq 0x48(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7af8
leaq 0xdd01(%rip), %rdi      # 0x15a0e
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0x6228(%rip), %rsi      # 0xdf4e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3270
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x7d4d
leaq 0x61f5(%rip), %rsi      # 0xdf38
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x7b65
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x7c18
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x7c18
leaq 0xeb83(%rip), %rdi      # 0x168fb
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x7d1f
movzbl 0x8(%rax), %ecx
cmpl $0x62, %ecx
je 0x7ccf
cmpl $0x6f, %ecx
je 0x7ccf
movq 0x30(%rax), %rax
jmp 0x7d9b
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: basetype_to_mxclassid(char const*)
char *basetype_to_mxclassid(const char* name)
{
  if( strcmp(name,"int32_t") == 0 ) return strdup("mxINT32_CLASS");
  if( strcmp(name,"int64_t") == 0 ) return strdup("mxINT64_CLASS");
  if( strcmp(name,"uint32_t") == 0 ) return strdup("mxUINT32_CLASS");
  if( strcmp(name,"uint64_t") == 0 ) return strdup("mxUINT64_CLASS");
  if( strcmp(name,"float") == 0 ) return strdup("mxSINGLE_CLASS");
  if( strcmp(name,"fcomplex") == 0 ) return strdup("mxSINGLE_CLASS");
  if( strcmp(name,"double") == 0 ) return strdup("mxDOUBLE_CLASS");
  if( strcmp(name,"dcomplex") == 0 ) return strdup("mxDOUBLE_CLASS");
  return strdup("mxVOID_CLASS");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5cb2(%rip), %rsi      # 0xdace
callq 0x3260
testl %eax, %eax
je 0x7ebb
leaq 0x5ca7(%rip), %rsi      # 0xdad7
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7ec4
leaq 0x5c86(%rip), %rsi      # 0xdacd
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7ecd
leaq 0x5c7c(%rip), %rsi      # 0xdad6
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7edf
leaq 0x5c42(%rip), %rsi      # 0xdaaf
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7ed6
leaq 0x55b6(%rip), %rsi      # 0xd436
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7ed6
leaq 0x5c15(%rip), %rsi      # 0xdaa8
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7ee8
leaq 0x5587(%rip), %rsi      # 0xd42d
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7ee8
leaq 0xbcce(%rip), %rdi      # 0x13b87
jmp 0x7eef
leaq 0xbc6d(%rip), %rdi      # 0x13b2f
jmp 0x7eef
leaq 0xbc72(%rip), %rdi      # 0x13b3d
jmp 0x7eef
leaq 0xbc77(%rip), %rdi      # 0x13b4b
jmp 0x7eef
leaq 0xbc8c(%rip), %rdi      # 0x13b69
jmp 0x7eef
leaq 0xbc74(%rip), %rdi      # 0x13b5a
jmp 0x7eef
leaq 0xbc89(%rip), %rdi      # 0x13b78
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: nullable_return(Func*)
bool nullable_return(Func* f)
{
    return (f->ret &&
            (f->ret->tinfo == VT_string ||
             is_array(f->ret->tinfo) ||
             f->ret->tinfo == VT_p_scalar ||
             f->ret->tinfo == VT_p_cscalar ||
             f->ret->tinfo == VT_p_zscalar));
}

// Assembly:
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x7f59
pushq %rbp
movq %rsp, %rbp
movl 0x20(%rax), %ecx
leal -0x2(%rcx), %edx
cmpl $0x8, %edx
jae 0x7f4e
movb $0x1, %al
movl $0x87, %esi
btl %edx, %esi
jb 0x7f57
addl $-0xc, %ecx
cmpl $0x3, %ecx
setb %al
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: vname(Var*, char*)
const char* vname(Var* v, char* buf)
{
    if (v->iospec == 'o')
        sprintf(buf, "out%d_", v->output_label);
    else
        sprintf(buf, "in%d_", v->input_label);
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x6f, 0x8(%rdi)
jne 0x7f77
movl 0x4(%rdi), %edx
leaq 0xbc1f(%rip), %rsi      # 0x13b94
jmp 0x7f80
movl (%rdi), %edx
leaq 0xbc1b(%rip), %rsi      # 0x13b9b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: max_routine_id(Func*)
int max_routine_id(Func* f)
{
    int maxid = 0;
    for (; f; f=f->next)
        if (f->id > maxid)
            maxid = f->id;
    return maxid;
}

// Assembly:
testq %rdi, %rdi
je 0x7fe8
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl 0x28(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
jne 0x7fd5
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_zcopiers(_IO_FILE*, char const*, char const*)
void mex_define_zcopiers(FILE* fp, const char* name, const char* ztype)
{
    /* Define complex copiers */
    fprintf(fp,
            "mxWrapGetScalarZDef(mxWrapGetScalar_%s, %s,\n"
            "                    %s, setz_%s)\n",
            name, name, ztype, name);
    fprintf(fp,
            "mxWrapGetArrayZDef (mxWrapGetArray_%s, %s,\n"
            "                    %s, setz_%s)\n",
            name, name, ztype, name);
    fprintf(fp,
            "mxWrapCopyZDef     (mxWrapCopy_%s, %s,\n"
            "                    real_%s, imag_%s)\n",
            name, name, name, name);
    fprintf(fp,
            "mxWrapReturnZDef   (mxWrapReturn_%s, %s,\n"
            "                    real_%s, imag_%s)\n",
            name, name, name, name);

    /* Single precision */
    fprintf(fp,
            "mxWrapGetScalarZDef_single(mxWrapGetScalar_single_%s, %s,\n"
            "                    %s, setz_%s)\n",
            name, name, ztype, name);
    fprintf(fp,
            "mxWrapGetArrayZDef_single (mxWrapGetArray_single_%s, %s,\n"
            "                    %s, setz_%s)\n",
            name, name, ztype, name);
    fprintf(fp,
            "mxWrapCopyZDef_single     (mxWrapCopy_single_%s, %s,\n"
            "                    real_%s, imag_%s)\n",
            name, name, name, name);
    fprintf(fp,
            "mxWrapReturnZDef_single   (mxWrapReturn_single_%s, %s,\n"
            "                    real_%s, imag_%s)\n",
            name, name, name, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xbdb1(%rip), %rsi      # 0x13faa
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbde5(%rip), %rsi      # 0x13ff8
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbe15(%rip), %rsi      # 0x14045
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbe46(%rip), %rsi      # 0x14093
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbe79(%rip), %rsi      # 0x140e3
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbeb8(%rip), %rsi      # 0x1413f
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbef6(%rip), %rsi      # 0x1419a
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbf35(%rip), %rsi      # 0x141f6
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_copiers(_IO_FILE*)
void mex_define_copiers(FILE* fp)
{
    fprintf(fp, "\n\n\n");
    fprintf(fp, "/* Array copier definitions */\n");
    for( set<string>::iterator iter = scalar_decls.begin();
         iter != scalar_decls.end();
         ++iter){
        mex_define_copiers(fp, iter->c_str());
    }
    for( set<string>::iterator iter = cscalar_decls.begin();
         iter != cscalar_decls.end();
         ++iter)
        mex_define_zcopiers(fp, iter->c_str(), "float");
    for( set<string>::iterator iter = zscalar_decls.begin();
         iter != zscalar_decls.end();
         ++iter)
        mex_define_zcopiers(fp, iter->c_str(), "double");
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xbf5e(%rip), %rdi      # 0x14254
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0xbf49(%rip), %rdi      # 0x14258
movl $0x1f, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0x14150(%rip), %r15     # 0x1c478
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0x8351
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x8063
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
cmpq %r15, %rax
jne 0x8335
leaq 0x14150(%rip), %r12     # 0x1c4a8
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x838c
leaq 0x5742(%rip), %r15      # 0xdaaf
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x81df
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
cmpq %r12, %rax
jne 0x836d
leaq 0x14145(%rip), %r12     # 0x1c4d8
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x83c7
leaq 0x5700(%rip), %r15      # 0xdaa8
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x81df
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
cmpq %r12, %rax
jne 0x83a8
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_caps_fname(_IO_FILE*, Func*)
void mex_define_caps_fname(FILE* fp, Func* f)
{
    fprintf(fp, "#define MWF77_%s ", f->funcv);
    for (char* s = f->funcv; *s; ++s)
        fputc(toupper(*s), fp);
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdx
leaq 0xbe84(%rip), %rsi      # 0x14278
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0x8425
incq %r14
movsbl %al, %edi
callq 0x3330
movl %eax, %edi
movq %rbx, %rsi
callq 0x3230
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x8409
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_caps_fnames(_IO_FILE*, Func*)
void mex_define_caps_fnames(FILE* fp, Func* f)
{
    set<string> fnames;
    for (; f; f = f->next) {
        if (f->fort && fnames.find(f->funcv) == fnames.end()) {
            mex_define_caps_fname(fp, f);
            fnames.insert(f->funcv);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x58(%rbp)
leaq -0x80(%rbp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
testq %rsi, %rsi
je 0x8513
movq %rsi, %rbx
leaq -0x50(%rbp), %r15
leaq -0x29(%rbp), %r12
leaq -0x88(%rbp), %r13
cmpb $0x1, 0x24(%rbx)
jne 0x8506
movq 0x40(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6a76
movq %r13, %rdi
movq %r15, %rsi
callq 0x716a
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x84be
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0x80(%rbp), %rax
cmpq %rax, %r14
jne 0x8506
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x83dc
movq 0x40(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6a76
movq %r13, %rdi
movq %r15, %rsi
callq 0x6fba
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x8506
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x8482
leaq -0x88(%rbp), %rdi
callq 0x6b4e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8532
jmp 0x8550
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x8553
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
jmp 0x8553
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x6b4e
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_underscore1_fname(_IO_FILE*, Func*)
void mex_define_underscore1_fname(FILE* fp, Func* f)
{
    fprintf(fp, "#define MWF77_%s ", f->funcv);
    for (char* s = f->funcv; *s; ++s)
        fputc(tolower(*s), fp);
    fprintf(fp, "_\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdx
leaq 0xbcf9(%rip), %rsi      # 0x14278
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0x85b0
incq %r14
movsbl %al, %edi
callq 0x3280
movl %eax, %edi
movq %rbx, %rsi
callq 0x3230
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x8594
leaq 0xbcd4(%rip), %rdi      # 0x1428b
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_underscore1_fnames(_IO_FILE*, Func*)
void mex_define_underscore1_fnames(FILE* fp, Func* f)
{
    set<string> fnames;
    for (; f; f = f->next) {
        if (f->fort && fnames.find(f->funcv) == fnames.end()) {
            mex_define_underscore1_fname(fp, f);
            fnames.insert(f->funcv);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x58(%rbp)
leaq -0x80(%rbp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
testq %rsi, %rsi
je 0x86aa
movq %rsi, %rbx
leaq -0x50(%rbp), %r15
leaq -0x29(%rbp), %r12
leaq -0x88(%rbp), %r13
cmpb $0x1, 0x24(%rbx)
jne 0x869d
movq 0x40(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6a76
movq %r13, %rdi
movq %r15, %rsi
callq 0x716a
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x8655
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0x80(%rbp), %rax
cmpq %rax, %r14
jne 0x869d
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x8567
movq 0x40(%rbx), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x6a76
movq %r13, %rdi
movq %r15, %rsi
callq 0x6fba
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x869d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x8619
leaq -0x88(%rbp), %rdi
callq 0x6b4e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x86c9
jmp 0x86e7
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x86ea
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
jmp 0x86ea
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x6b4e
movq %rbx, %rdi
callq 0x32f0