LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x7377
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x7371
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x7330
movq 0x30(%r14), %r14
jmp 0x7357
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x73bd
movzbl 0x8(%rdi), %eax
cmpl $0x62, %eax
je 0x7398
cmpl $0x6f, %eax
je 0x73ad
cmpl $0x69, %eax
jne 0x73b7
movl (%rsi), %ecx
leal 0x1(%rcx), %r8d
movl %r8d, (%rsi)
movl %ecx, (%rdi)
cmpl $0x6f, %eax
je 0x73ad
cmpl $0x62, %eax
jne 0x73b7
movl (%rdx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdx)
movl %eax, 0x4(%rdi)
movq 0x30(%rdi), %rdi
jmp 0x7380
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x73e2
movl $0x1, -0x1c(%rbp)
movq 0x50(%rbx), %rdi
leaq -0x1c(%rbp), %r14
leaq -0x20(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x737c
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x737c
movq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x734a
movq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x734a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x66e4(%rip), %r12      # 0xdb2c
testq %r15, %r15
je 0x74b3
movl 0x20(%r15), %eax
xorl %r13d, %r13d
decl %eax
cmpl $0x11, %eax
ja 0x7480
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movl $0xc, 0x20(%r15)
jmp 0x7480
movl $0xe, 0x20(%r15)
jmp 0x7480
movl $0xd, 0x20(%r15)
movq 0x30(%r15), %r15
addl %r13d, %r14d
jmp 0x7448
movl %ebx, %edi
movq %r15, %rsi
callq 0x3508
jmp 0x749f
movl %ebx, %edi
movq %r15, %rsi
callq 0x34cb
movl $0x1, %r13d
jmp 0x7480
movl %ebx, %edi
movq %r15, %rsi
callq 0x348e
jmp 0x7480
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74da
movl 0x20(%rdi), %eax
cmpl $0x6, %eax
jne 0x74e3
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addl $-0x7, %eax
movl %esi, %edi
cmpl $0x1, %eax
ja 0x74f4
callq 0x3545
jmp 0x74da
callq 0x3580
movl $0x1, %ebx
jmp 0x74da
// File: /workspace/github_cpp_makefile_star2_O1/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 0x753b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x742b
movl %eax, %r15d
movq 0x50(%r14), %rdi
movl %ebx, %esi
callq 0x74c5
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7568
movzbl (%rax), %edx
cmpl $0x60, %edx
jg 0x756e
cmpl $0x26, %edx
je 0x75aa
cmpl $0x2a, %edx
jne 0x75ee
movl %ecx, 0x20(%r10)
jmp 0x75ae
movl %edx, 0x20(%r10)
jmp 0x75ae
cmpl $0x61, %edx
je 0x75b2
cmpl $0x72, %edx
jne 0x75ee
movl 0x10(%rbp), %ecx
movl %ecx, 0x20(%r10)
testl %ecx, %ecx
je 0x75dd
movq 0x8(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x75b0
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x75b0
cmpq $0x0, 0x10(%rcx)
je 0x75b0
movl %esi, %edi
movq %r10, %rsi
callq 0x35bb
jmp 0x75e7
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 0x75b0
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x75b0
cmpq $0x0, 0x10(%rcx)
je 0x75b0
movl %esi, %edi
movq %r10, %rsi
callq 0x3635
jmp 0x75e7
movl %esi, %edi
movq %r10, %rsi
callq 0x35f8
movl $0x1, %eax
jmp 0x75b0
leaq 0x6961(%rip), %rdi      # 0xdf56
leaq 0x66ac(%rip), %rsi      # 0xdca8
leaq 0x66b8(%rip), %rcx      # 0xdcbb
movl $0xb3, %edx
callq 0x3100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x78dc
movl %esi, %r14d
movq %rdi, %r15
callq 0x760d
movl %eax, %ebx
movl 0x20(%r15), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
ja 0x788c
movq 0x18(%r15), %rcx
testq %rcx, %rcx
je 0x791b
cmpq $0x0, 0x8(%rcx)
je 0x791b
cmpl $0x9, %eax
je 0x78e3
cmpl $0x5, %eax
je 0x7948
cmpl $0x13, %eax
jne 0x797c
movq 0x1472e(%rip), %r15     # 0x1bfd8
movq (%r15), %rdi
leaq 0x62d8(%rip), %rsi      # 0xdb8c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r15), %rcx
leaq 0x6521(%rip), %rdi      # 0xdde9
movl $0x17, %esi
movl $0x1, %edx
callq 0x3370
jmp 0x797a
xorl %ebx, %ebx
jmp 0x797c
cmpq $0x0, 0x18(%r15)
je 0x797c
movq 0x146e3(%rip), %r12     # 0x1bfd8
movq (%r12), %rdi
leaq 0x628c(%rip), %rsi      # 0xdb8c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x6519(%rip), %rsi      # 0xde32
jmp 0x7973
movq 0x146b6(%rip), %r12     # 0x1bfd8
movq (%r12), %rdi
leaq 0x625f(%rip), %rsi      # 0xdb8c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x6483(%rip), %rsi      # 0xddc9
jmp 0x7973
movq 0x14689(%rip), %r12     # 0x1bfd8
movq (%r12), %rdi
leaq 0x6232(%rip), %rsi      # 0xdb8c
movl %r14d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x648e(%rip), %rsi      # 0xde01
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_O1/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 0x73bf
movq 0x50(%r14), %rdi
movl %ebx, %esi
callq 0x7847
movl %eax, %r15d
movq 0x48(%r14), %rdi
movl %ebx, %esi
callq 0x7987
movl %eax, %r12d
addl %r15d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x7500
addl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xdfeb(%rip), %r12      # 0x15bd4
testq %r14, %r14
je 0x7c2f
movzbl 0x8(%r14), %eax
cmpl $0x6f, %eax
je 0x7bfd
cmpl $0x62, %eax
jne 0x7c29
cmpl $0x0, (%rbx)
jne 0x7c17
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
jmp 0x7be9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6304(%rip), %r15      # 0xdf54
leaq 0x6301(%rip), %r12      # 0xdf58
testq %rbx, %rbx
je 0x7c9e
cmpl $0x13, 0x20(%rbx)
jne 0x7c79
movl $0x3, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3370
jmp 0x7c98
movzbl 0x8(%rbx), %eax
cmpl $0x69, %eax
je 0x7c87
cmpl $0x62, %eax
jne 0x7c98
movq 0x28(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x30(%rbx), %rbx
jmp 0x7c57
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x7d12
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x7d0c
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x7ca7
movq 0x30(%rbx), %rbx
jmp 0x7cf2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67e0
movq (%r12), %rdx
leaq 0x6217(%rip), %rsi      # 0xdf5d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x7d69
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3180
cmpq $0x0, 0x50(%r14)
jne 0x7d7d
movq 0x48(%r14), %rdi
callq 0x7ba8
testl %eax, %eax
je 0x7dc9
movl $0x1, (%r12)
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x3230
movq 0x50(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7bce
movq 0x48(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7bce
leaq 0xdc77(%rip), %rdi      # 0x15a2e
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0x619e(%rip), %rsi      # 0xdf6e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3270
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x7df7
leaq 0x616b(%rip), %rsi      # 0xdf58
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x7c38
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x7ce5
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x7ce5
leaq 0xeaf9(%rip), %rdi      # 0x1691b
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
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c36(%rip), %rsi      # 0xdad6
callq 0x3260
testl %eax, %eax
je 0x7f3f
leaq 0x5c2b(%rip), %rsi      # 0xdadf
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f48
leaq 0x5c0a(%rip), %rsi      # 0xdad5
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f51
leaq 0x5c00(%rip), %rsi      # 0xdade
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f63
leaq 0x5bc6(%rip), %rsi      # 0xdab7
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f5a
leaq 0x5532(%rip), %rsi      # 0xd436
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f5a
leaq 0x5b99(%rip), %rsi      # 0xdab0
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f6c
leaq 0x5503(%rip), %rsi      # 0xd42d
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x7f6c
leaq 0xbc6a(%rip), %rdi      # 0x13ba7
jmp 0x7f73
leaq 0xbc09(%rip), %rdi      # 0x13b4f
jmp 0x7f73
leaq 0xbc0e(%rip), %rdi      # 0x13b5d
jmp 0x7f73
leaq 0xbc13(%rip), %rdi      # 0x13b6b
jmp 0x7f73
leaq 0xbc28(%rip), %rdi      # 0x13b89
jmp 0x7f73
leaq 0xbc10(%rip), %rdi      # 0x13b7a
jmp 0x7f73
leaq 0xbc25(%rip), %rdi      # 0x13b98
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7fdd
pushq %rbp
movq %rsp, %rbp
movl 0x20(%rax), %ecx
leal -0x2(%rcx), %edx
cmpl $0x8, %edx
jae 0x7fd2
movb $0x1, %al
movl $0x87, %esi
btl %edx, %esi
jb 0x7fdb
addl $-0xc, %ecx
cmpl $0x3, %ecx
setb %al
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ffb
movl 0x4(%rdi), %edx
leaq 0xbbbb(%rip), %rsi      # 0x13bb4
jmp 0x8004
movl (%rdi), %edx
leaq 0xbbb7(%rip), %rsi      # 0x13bbb
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_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: has_fortran(Func*)
bool has_fortran(Func* f)
{
    for (; f; f=f->next)
        if (f->fort)
            return true;
    return false;
}

// Assembly:
testq %rdi, %rdi
setne %al
je 0x803d
cmpb $0x0, 0x24(%rdi)
jne 0x803d
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
setne %al
je 0x803c
cmpb $0x0, 0x24(%rdi)
je 0x802a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8074
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 0x8061
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbd45(%rip), %rsi      # 0x13fca
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbd79(%rip), %rsi      # 0x14018
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbda9(%rip), %rsi      # 0x14065
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbdda(%rip), %rsi      # 0x140b3
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbe0d(%rip), %rsi      # 0x14103
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbe4c(%rip), %rsi      # 0x1415f
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbe8a(%rip), %rsi      # 0x141ba
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3270
leaq 0xbec9(%rip), %rsi      # 0x14216
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_O1/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 0xbef2(%rip), %rdi      # 0x14274
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0xbedd(%rip), %rdi      # 0x14278
movl $0x1f, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0x140c4(%rip), %r15     # 0x1c478
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0x83dd
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x80ef
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
cmpq %r15, %rax
jne 0x83c1
leaq 0x140c4(%rip), %r12     # 0x1c4a8
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x8418
leaq 0x56be(%rip), %r15      # 0xdab7
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x826b
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
cmpq %r12, %rax
jne 0x83f9
leaq 0x140b9(%rip), %r12     # 0x1c4d8
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x8453
leaq 0x567c(%rip), %r15      # 0xdab0
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x826b
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
cmpq %r12, %rax
jne 0x8434
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbe18(%rip), %rsi      # 0x14298
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0x84b1
incq %r14
movsbl %al, %edi
callq 0x3330
movl %eax, %edi
movq %rbx, %rsi
callq 0x3230
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x8495
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x88, %rsp
movq %rdi, -0x38(%rbp)
leaq -0xa0(%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 0x85c3
movq %rsi, %rbx
leaq -0x78(%rbp), %r15
leaq -0x58(%rbp), %r12
movq %r15, %r13
movb 0x24(%rbx), %r14b
cmpb $0x1, %r14b
jne 0x8549
movq 0x40(%rbx), %rsi
movq %r15, %rdi
leaq -0x2a(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x7292
leaq -0xa0(%rbp), %rcx
cmpq %rcx, %rax
sete %r15b
jmp 0x854c
xorl %r15d, %r15d
testb %r14b, %r14b
je 0x856a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x856a
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3180
testb %r15b, %r15b
movq %r13, %r15
je 0x85b6
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x8468
movq 0x40(%rbx), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x70d8
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x85b6
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x8510
leaq -0xa8(%rbp), %rdi
callq 0x6c66
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x85e3
movq %rax, %rbx
jmp 0x861a
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x861a
movq -0x68(%rbp), %rsi
jmp 0x8612
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x861a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x6c66
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbc52(%rip), %rsi      # 0x14298
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0x8677
incq %r14
movsbl %al, %edi
callq 0x3280
movl %eax, %edi
movq %rbx, %rsi
callq 0x3230
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x865b
leaq 0xbc2d(%rip), %rdi      # 0x142ab
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x88, %rsp
movq %rdi, -0x38(%rbp)
leaq -0xa0(%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 0x8795
movq %rsi, %rbx
leaq -0x78(%rbp), %r15
leaq -0x58(%rbp), %r12
movq %r15, %r13
movb 0x24(%rbx), %r14b
cmpb $0x1, %r14b
jne 0x871b
movq 0x40(%rbx), %rsi
movq %r15, %rdi
leaq -0x2a(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x7292
leaq -0xa0(%rbp), %rcx
cmpq %rcx, %rax
sete %r15b
jmp 0x871e
xorl %r15d, %r15d
testb %r14b, %r14b
je 0x873c
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x873c
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3180
testb %r15b, %r15b
movq %r13, %r15
je 0x8788
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x862e
movq 0x40(%rbx), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x70d8
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x8788
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x86e2
leaq -0xa8(%rbp), %rdi
callq 0x6c66
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x87b5
movq %rax, %rbx
jmp 0x87ec
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x87ec
movq -0x68(%rbp), %rsi
jmp 0x87e4
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x87ec
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x6c66
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_underscore0_fname(_IO_FILE*, Func*)
void mex_define_underscore0_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 0xba80(%rip), %rsi      # 0x14298
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0x8849
incq %r14
movsbl %al, %edi
callq 0x3280
movl %eax, %edi
movq %rbx, %rsi
callq 0x3230
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x882d
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_underscore0_fnames(_IO_FILE*, Func*)
void mex_define_underscore0_fnames(FILE* fp, Func* f)
{
    set<string> fnames;
    for (; f; f = f->next) {
        if (f->fort && fnames.find(f->funcv) == fnames.end()) {
            mex_define_underscore0_fname(fp, f);
            fnames.insert(f->funcv);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x38(%rbp)
leaq -0xa0(%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 0x895b
movq %rsi, %rbx
leaq -0x78(%rbp), %r15
leaq -0x58(%rbp), %r12
movq %r15, %r13
movb 0x24(%rbx), %r14b
cmpb $0x1, %r14b
jne 0x88e1
movq 0x40(%rbx), %rsi
movq %r15, %rdi
leaq -0x2a(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x7292
leaq -0xa0(%rbp), %rcx
cmpq %rcx, %rax
sete %r15b
jmp 0x88e4
xorl %r15d, %r15d
testb %r14b, %r14b
je 0x8902
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x8902
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3180
testb %r15b, %r15b
movq %r13, %r15
je 0x894e
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x8800
movq 0x40(%rbx), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x70d8
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x894e
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x88a8
leaq -0xa8(%rbp), %rdi
callq 0x6c66
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x897b
movq %rax, %rbx
jmp 0x89b2
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x89b2
movq -0x68(%rbp), %rsi
jmp 0x89aa
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x89b2
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x6c66
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_f2c_fname(_IO_FILE*, Func*)
void mex_define_f2c_fname(FILE* fp, Func* f)
{
    fprintf(fp, "#define MWF77_%s ", f->funcv);
    bool has_underscore = false;
    for (char* s = f->funcv; *s; ++s) {
        has_underscore = (has_underscore || (*s == '_'));
        fputc(tolower(*s), fp);
    }
    if (has_underscore)
        fprintf(fp, "__\n");
    else
        fprintf(fp, "_\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdx
leaq 0xb8b7(%rip), %rsi      # 0x14298
xorl %eax, %eax
callq 0x3270
movq 0x40(%r14), %r14
movb (%r14), %al
testb %al, %al
je 0x8a31
incq %r14
xorl %r15d, %r15d
cmpb $0x5f, %al
sete %cl
orb %cl, %r15b
movsbl %al, %edi
callq 0x3280
movl %eax, %edi
movq %rbx, %rsi
callq 0x3230
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x89f9
testb $0x1, %r15b
je 0x8a31
leaq 0xb880(%rip), %rdi      # 0x142aa
movl $0x3, %esi
jmp 0x8a3d
leaq 0xb873(%rip), %rdi      # 0x142ab
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_f2c_fnames(_IO_FILE*, Func*)
void mex_define_f2c_fnames(FILE* fp, Func* f)
{
    set<string> fnames;
    for (; f; f = f->next) {
        if (f->fort && fnames.find(f->funcv) == fnames.end()) {
            mex_define_f2c_fname(fp, f);
            fnames.insert(f->funcv);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x38(%rbp)
leaq -0xa0(%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 0x8b55
movq %rsi, %rbx
leaq -0x78(%rbp), %r15
leaq -0x58(%rbp), %r12
movq %r15, %r13
movb 0x24(%rbx), %r14b
cmpb $0x1, %r14b
jne 0x8adb
movq 0x40(%rbx), %rsi
movq %r15, %rdi
leaq -0x2a(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x7292
leaq -0xa0(%rbp), %rcx
cmpq %rcx, %rax
sete %r15b
jmp 0x8ade
xorl %r15d, %r15d
testb %r14b, %r14b
je 0x8afc
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x8afc
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3180
testb %r15b, %r15b
movq %r13, %r15
je 0x8b48
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x89c6
movq 0x40(%rbx), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x70d8
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x8b48
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x8aa2
leaq -0xa8(%rbp), %rdi
callq 0x6c66
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b75
movq %rax, %rbx
jmp 0x8bac
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x8bac
movq -0x68(%rbp), %rsi
jmp 0x8ba4
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x8bac
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x6c66
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_define_fnames(_IO_FILE*, Func*)
void mex_define_fnames(FILE* fp, Func* f)
{
    fprintf(fp, "#if defined(MWF77_CAPS)\n");
    mex_define_caps_fnames(fp, f);
    fprintf(fp, "#elif defined(MWF77_UNDERSCORE1)\n");
    mex_define_underscore1_fnames(fp, f);
    fprintf(fp, "#elif defined(MWF77_UNDERSCORE0)\n");
    mex_define_underscore0_fnames(fp, f);
    fprintf(fp, "#else /* f2c convention */\n");
    mex_define_f2c_fnames(fp, f);
    fprintf(fp, "#endif\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb6da(%rip), %rdi      # 0x142ae
movl $0x18, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84c2
leaq 0xb6cf(%rip), %rdi      # 0x142c7
movl $0x21, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8694
leaq 0xb6cd(%rip), %rdi      # 0x142e9
movl $0x21, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x885a
leaq 0xb6cb(%rip), %rdi      # 0x1430b
movl $0x1b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a54
leaq 0xb792(%rip), %rdi      # 0x143f6
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_fortran_arg(_IO_FILE*, Var*)
void mex_fortran_arg(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->tinfo == VT_mx)
        fprintf(fp, "const mxArray*");
    else
        fprintf(fp, "%s*", v->basetype);
    if (v->next) {
        fprintf(fp, ", ");
        mex_fortran_arg(fp, v->next);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb692(%rip), %r15      # 0x14327
leaq 0xcf38(%rip), %r12      # 0x15bd4
leaq 0xbad9(%rip), %r13      # 0x1477c
testq %rbx, %rbx
je 0x8cf8
cmpl $0xa, 0x20(%rbx)
jne 0x8cc5
movl $0xe, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3370
jmp 0x8cd6
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x3270
cmpq $0x0, 0x30(%rbx)
je 0x8cf8
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x3370
movq 0x30(%rbx), %rbx
jmp 0x8ca3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_fortran_decl(_IO_FILE*, Func*)
void mex_fortran_decl(FILE* fp, Func* f)
{
    if (f->ret)
        fprintf(fp, "%s ", f->ret->basetype);
    else
        fprintf(fp, "MWF77_RETURN ");
    fprintf(fp, "MWF77_%s(", f->funcv);
    mex_fortran_arg(fp, f->args);
    fprintf(fp, ");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %rax
testq %rax, %rax
je 0x8d34
movq 0x10(%rax), %rdx
leaq 0xb57e(%rip), %rsi      # 0x142a6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
jmp 0x8d4d
leaq 0xb5fb(%rip), %rdi      # 0x14336
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq 0x40(%r14), %rdx
leaq 0xb5ec(%rip), %rsi      # 0x14344
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x8c7a
leaq 0xdba6(%rip), %rdi      # 0x1691b
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_fortran_decls(_IO_FILE*, Func*)
void mex_fortran_decls(FILE* fp, Func* f)
{
    fprintf(fp,
            "#ifdef __cplusplus\n"
            "extern \"C\" { /* Prevent C++ name mangling */\n"
            "#endif\n\n"
            "#ifndef MWF77_RETURN\n"
            "#define MWF77_RETURN int\n"
            "#endif\n\n");

    set<string> fnames;
    for (; f; f = f->next) {
        if (f->fort && fnames.find(f->funcv) == fnames.end()) {
            mex_fortran_decl(fp, f);
            fnames.insert(f->funcv);
        }
    }

    fprintf(fp,
            "\n#ifdef __cplusplus\n"
            "} /* end extern C */\n"
            "#endif\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rcx
leaq 0xb5a2(%rip), %rdi      # 0x1434e
movl $0x7e, %esi
movl $0x1, %edx
movq %rcx, -0x38(%rbp)
callq 0x3370
leaq -0xa0(%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 %r14, %r14
je 0x8ea5
leaq -0x78(%rbp), %r13
leaq -0x58(%rbp), %rbx
movq %r13, %r12
movb 0x24(%r14), %r15b
cmpb $0x1, %r15b
jne 0x8e2b
movq 0x40(%r14), %rsi
movq %r13, %rdi
leaq -0x2a(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %r13, %rsi
callq 0x7292
leaq -0xa0(%rbp), %rcx
cmpq %rcx, %rax
sete %r13b
jmp 0x8e2e
xorl %r13d, %r13d
testb %r15b, %r15b
je 0x8e4c
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x8e4c
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3180
testb %r13b, %r13b
movq %r12, %r13
je 0x8e98
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x8d07
movq 0x40(%r14), %rsi
movq %rbx, %rdi
leaq -0x29(%rbp), %rdx
callq 0x6b8e
leaq -0xa8(%rbp), %rdi
movq %rbx, %rsi
callq 0x70d8
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x8e98
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
movq 0x58(%r14), %r14
testq %r14, %r14
jne 0x8df2
leaq 0xb521(%rip), %rdi      # 0x143cd
movl $0x31, %esi
movl $0x1, %edx
movq -0x38(%rbp), %rcx
callq 0x3370
leaq -0xa8(%rbp), %rdi
callq 0x6c66
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8edf
movq %rax, %rbx
jmp 0x8f16
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x8f16
movq -0x68(%rbp), %rsi
jmp 0x8f0e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x8f16
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x6c66
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_casting_getter(_IO_FILE*, char const*, InheritsDecl*)
void mex_casting_getter(FILE* fp, const char* cname,
                        InheritsDecl* inherits)
{
    fprintf(fp, "\n%s* mxWrapGetP_%s(const mxArray* a, const char** e)\n",
            cname, cname);
    fprintf(fp,
            "{\n"
            "    char pbuf[128];\n"
            "    if (mxGetClassID(a) == mxDOUBLE_CLASS &&\n"
            "        mxGetM(a)*mxGetN(a) == 1 &&\n"
            "#if MX_HAS_INTERLEAVED_COMPLEX\n"
	    "        ((mxIsComplex(a) ? *mxGetComplexDoubles(a) == 0 : *mxGetDoubles(a) == 0)\n"
	    "#else\n"
	    "        *mxGetPr(a) == 0\n"
	    "#endif\n"
            "        )\n"
            "        return NULL;\n"
            "    if (!mxIsChar(a)) {\n"
            "#ifdef R2008OO\n"
            "        mxArray* ap = mxGetProperty(a, 0, \"mwptr\");\n"
            "        if (ap)\n"
            "            return mxWrapGetP_%s(ap, e);\n"
            "#endif\n"
            "        *e = \"Invalid pointer\";\n"
            "        return NULL;\n"
            "    }\n"
            "    mxGetString(a, pbuf, sizeof(pbuf));\n\n", cname);

    mex_casting_getter_type(fp, cname);
    for (InheritsDecl* i = inherits; i; i = i->next)
        mex_casting_getter_type(fp, i->name);

    fprintf(fp,
            "    *e = \"Invalid pointer to %s\";\n"
            "    return NULL;\n"
            "}\n\n", cname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb4f1(%rip), %rsi      # 0x1445c
movq %rbx, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3270
leaq 0xb513(%rip), %rsi      # 0x14492
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
leaq 0xb46c(%rip), %rsi      # 0x143ff
movq %r14, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
movq %rbx, %r8
movq %rbx, %r9
xorl %eax, %eax
pushq %rbx
pushq %rbx
callq 0x3270
addq $0x10, %rsp
testq %r15, %r15
je 0x8fe3
leaq 0xb444(%rip), %r12      # 0x143ff
movq (%r15), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rcx, %rdx
movq %rcx, %r8
movq %rcx, %r9
xorl %eax, %eax
pushq %rcx
pushq %rcx
callq 0x3270
addq $0x10, %rsp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x8fbb
leaq 0xb6c4(%rip), %rsi      # 0x146ae
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_cast_get_p(_IO_FILE*, char const*, int)
void mex_cast_get_p(FILE* fp, const char* basetype, int input_label)
{
    fprintf(fp, "    in%d_ = ", input_label);
    if (is_mxarray_type(basetype))
        fprintf(fp, "mxWrapGet_%s(prhs[%d], &mw_err_txt_);\n",
                basetype, input_label);
    else if (class_decls.find(basetype) == class_decls.end())
        fprintf(fp, "(%s*) mxWrapGetP(prhs[%d], \"%s:%%p\", &mw_err_txt_);\n",
                basetype, input_label, basetype);
    else
        fprintf(fp, "mxWrapGetP_%s(prhs[%d], &mw_err_txt_);\n",
                basetype, input_label);
    fprintf(fp,
            "    if (mw_err_txt_)\n"
            "        goto mw_err_label;\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb679(%rip), %rsi      # 0x146e5
xorl %eax, %eax
callq 0x3270
movq %r15, %rdi
callq 0x608e
testb %al, %al
je 0x9088
leaq 0xb66c(%rip), %rsi      # 0x146f2
jmp 0x90d9
leaq -0x50(%rbp), %r13
leaq -0x29(%rbp), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x6b8e
leaq 0x133a6(%rip), %r12     # 0x1c448
movq %r12, %rdi
movq %r13, %rsi
callq 0xb0c2
movq %rax, %r13
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90c9
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
addq $0x8, %r12
cmpq %r12, %r13
je 0x9111
leaq 0xb675(%rip), %rsi      # 0x1474e
movq %rbx, %rdi
movq %r15, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3270
leaq 0xc1d1(%rip), %rdi      # 0x152c1
movl $0x31, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb601(%rip), %rsi      # 0x14719
movq %rbx, %rdi
movq %r15, %rdx
movl %r14d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x3270
jmp 0x90e9
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9149
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x32f0