LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9200
cmpq $0x0, -0x10(%rbp)
je 0xd9f3
movq -0x10(%rbp), %rax
movb 0x24(%rax), %cl
movb $0x0, -0x6a(%rbp)
movb $0x0, -0x7d(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc1(%rbp)
je 0xd87e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3420
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movb $0x1, -0x6a(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9150
jmp 0xd833
movb $0x1, -0x7d(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x92c0
movq %rax, -0xe0(%rbp)
jmp 0xd84d
movq -0xe0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9300
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x118a0
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
movb %al, -0xe1(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xd892
jmp 0xd89b
leaq -0x68(%rbp), %rdi
callq 0x34c8
testb $0x1, -0x6a(%rbp)
jne 0xd8a3
jmp 0xd8ac
leaq -0x69(%rbp), %rdi
callq 0x32a0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xd8bb
jmp 0xd9e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd730
jmp 0xd8ca
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0xf8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3420
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x9150
jmp 0xd908
leaq -0x40(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9240
movb %dl, -0x101(%rbp)
movq %rax, -0x100(%rbp)
jmp 0xd927
movb -0x101(%rbp), %al
movq -0x100(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movb %al, -0xb8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34c8
leaq -0xa9(%rbp), %rdi
callq 0x32a0
jmp 0xd9e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd98b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xd980
jmp 0xd989
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0xd98b
testb $0x1, -0x6a(%rbp)
jne 0xd993
jmp 0xd99c
leaq -0x69(%rbp), %rdi
callq 0x32a0
jmp 0xda05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xda05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd9d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34c8
leaq -0xa9(%rbp), %rdi
callq 0x32a0
jmp 0xda05
jmp 0xd9e2
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd7cc
leaq -0x40(%rbp), %rdi
callq 0x9220
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x9220
movq -0x78(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xd741(%rip), %rsi      # 0x1b184
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xda84
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x33b0
movl %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x3330
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xda56
movq -0x8(%rbp), %rdi
leaq 0xd6d3(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9200
cmpq $0x0, -0x10(%rbp)
je 0xdce3
movq -0x10(%rbp), %rax
movb 0x24(%rax), %cl
movb $0x0, -0x6a(%rbp)
movb $0x0, -0x7d(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc1(%rbp)
je 0xdb6e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3420
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movb $0x1, -0x6a(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9150
jmp 0xdb23
movb $0x1, -0x7d(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x92c0
movq %rax, -0xe0(%rbp)
jmp 0xdb3d
movq -0xe0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9300
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x118a0
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
movb %al, -0xe1(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xdb82
jmp 0xdb8b
leaq -0x68(%rbp), %rdi
callq 0x34c8
testb $0x1, -0x6a(%rbp)
jne 0xdb93
jmp 0xdb9c
leaq -0x69(%rbp), %rdi
callq 0x32a0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xdbab
jmp 0xdcd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xda20
jmp 0xdbba
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0xf8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3420
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x9150
jmp 0xdbf8
leaq -0x40(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9240
movb %dl, -0x101(%rbp)
movq %rax, -0x100(%rbp)
jmp 0xdc17
movb -0x101(%rbp), %al
movq -0x100(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movb %al, -0xb8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34c8
leaq -0xa9(%rbp), %rdi
callq 0x32a0
jmp 0xdcd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xdc7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xdc70
jmp 0xdc79
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0xdc7b
testb $0x1, -0x6a(%rbp)
jne 0xdc83
jmp 0xdc8c
leaq -0x69(%rbp), %rdi
callq 0x32a0
jmp 0xdcf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xdcf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xdcc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34c8
leaq -0xa9(%rbp), %rdi
callq 0x32a0
jmp 0xdcf5
jmp 0xdcd2
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xdabc
leaq -0x40(%rbp), %rdi
callq 0x9220
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x9220
movq -0x78(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xd451(%rip), %rsi      # 0x1b184
movb $0x0, %al
callq 0x33a0
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0xdd9b
movb $0x1, %al
testb $0x1, -0x11(%rbp)
movb %al, -0x21(%rbp)
jne 0xdd6e
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x33b0
movl %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x3330
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xdd4a
testb $0x1, -0x11(%rbp)
je 0xddb5
movq -0x8(%rbp), %rdi
leaq 0xd3ea(%rip), %rsi      # 0x1b196
movb $0x0, %al
callq 0x33a0
jmp 0xddc7
movq -0x8(%rbp), %rdi
leaq 0xd3d7(%rip), %rsi      # 0x1b197
movb $0x0, %al
callq 0x33a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9200
cmpq $0x0, -0x10(%rbp)
je 0xe013
movq -0x10(%rbp), %rax
movb 0x24(%rax), %cl
movb $0x0, -0x6a(%rbp)
movb $0x0, -0x7d(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc1(%rbp)
je 0xde9e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3420
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movb $0x1, -0x6a(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9150
jmp 0xde53
movb $0x1, -0x7d(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x92c0
movq %rax, -0xe0(%rbp)
jmp 0xde6d
movq -0xe0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9300
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x118a0
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
movb %al, -0xe1(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xdeb2
jmp 0xdebb
leaq -0x68(%rbp), %rdi
callq 0x34c8
testb $0x1, -0x6a(%rbp)
jne 0xdec3
jmp 0xdecc
leaq -0x69(%rbp), %rdi
callq 0x32a0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xdedb
jmp 0xe000
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd10
jmp 0xdeea
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0xf8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3420
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x9150
jmp 0xdf28
leaq -0x40(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9240
movb %dl, -0x101(%rbp)
movq %rax, -0x100(%rbp)
jmp 0xdf47
movb -0x101(%rbp), %al
movq -0x100(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movb %al, -0xb8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34c8
leaq -0xa9(%rbp), %rdi
callq 0x32a0
jmp 0xe000
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xdfab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xdfa0
jmp 0xdfa9
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0xdfab
testb $0x1, -0x6a(%rbp)
jne 0xdfb3
jmp 0xdfbc
leaq -0x69(%rbp), %rdi
callq 0x32a0
jmp 0xe025
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xe025
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xdff2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34c8
leaq -0xa9(%rbp), %rdi
callq 0x32a0
jmp 0xe025
jmp 0xe002
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xddec
leaq -0x40(%rbp), %rdi
callq 0x9220
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x9220
movq -0x78(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd13f(%rip), %rsi      # 0x1b19a
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd4c0
movq -0x8(%rbp), %rdi
leaq 0xd139(%rip), %rsi      # 0x1b1b3
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd7b0
movq -0x8(%rbp), %rdi
leaq 0xd13c(%rip), %rsi      # 0x1b1d5
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdaa0
movq -0x8(%rbp), %rdi
leaq 0xd13f(%rip), %rsi      # 0x1b1f7
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xddd0
movq -0x8(%rbp), %rdi
leaq 0xd20b(%rip), %rsi      # 0x1b2e2
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe109
jmp 0xe16f
movq -0x10(%rbp), %rax
cmpl $0xa, 0x20(%rax)
jne 0xe127
movq -0x8(%rbp), %rdi
leaq 0xd0f5(%rip), %rsi      # 0x1b213
movb $0x0, %al
callq 0x33a0
jmp 0xe141
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0xd52e(%rip), %rsi      # 0x1b668
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xe16f
movq -0x8(%rbp), %rdi
leaq 0xe96b(%rip), %rsi      # 0x1cac2
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xe0f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xe1bb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0xcfe0(%rip), %rsi      # 0x1b192
movb $0x0, %al
callq 0x33a0
jmp 0xe1cd
movq -0x8(%rbp), %rdi
leaq 0xd05c(%rip), %rsi      # 0x1b222
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xd050(%rip), %rsi      # 0x1b230
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xe0f0
movq -0x8(%rbp), %rdi
leaq 0xf606(%rip), %rsi      # 0x1d809
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xce31(%rip), %rsi      # 0x1b348
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xce51(%rip), %rsi      # 0x1b37e
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe4a0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe56e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0xe4a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe549
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xd01d(%rip), %rsi      # 0x1b59a
movb $0x0, %al
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0xcf8d(%rip), %rsi      # 0x1b5d1
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rdi
callq 0x8290
testb $0x1, %al
jne 0xe65a
jmp 0xe678
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0xcf72(%rip), %rsi      # 0x1b5de
movb $0x0, %al
callq 0x33a0
jmp 0xe761
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3420
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x9150
jmp 0xe6a0
leaq 0x16e41(%rip), %rdi     # 0x254e8
leaq -0x40(%rbp), %rsi
callq 0x118d0
movq %rax, -0x78(%rbp)
jmp 0xe6b6
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x16e23(%rip), %rdi     # 0x254e8
callq 0x94a0
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9fc0
movb %al, -0x79(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34c8
leaq -0x41(%rbp), %rdi
callq 0x32a0
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xe6f9
jmp 0xe746
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %r8
leaq 0xcef6(%rip), %rsi      # 0x1b605
movb $0x0, %al
callq 0x33a0
jmp 0xe75f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xe73b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34c8
leaq -0x41(%rbp), %rdi
callq 0x32a0
jmp 0xe77c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0xcee2(%rip), %rsi      # 0x1b63a
movb $0x0, %al
callq 0x33a0
jmp 0xe761
movq -0x8(%rbp), %rdi
leaq 0xda43(%rip), %rsi      # 0x1c1af
movb $0x0, %al
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_in_args(_IO_FILE*, Var*)
void mex_declare_in_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if ((v->iospec == 'i' || v->iospec == 'b') && v->tinfo != VT_const) {
        char typebuf[128];
        mex_declare_type(typebuf, v);
        if (is_array(v->tinfo) || is_obj(v->tinfo) || v->tinfo == VT_string) {
            fprintf(fp, "    %-10s  in%d_ =0; /* %-10s */\n",
                    typebuf, v->input_label, v->name);
            if(v->devicespec == 'g'){
                fprintf(fp, "    %-10s *mxGPUArray_in%d_ =0; /* %-10s */\n",
                       "mxGPUArray const", v->input_label, v->name);
            }
        } else {
            fprintf(fp, "    %-10s  in%d_;    /* %-10s */\n",
                    typebuf, v->input_label, v->name);
        }
    }
    mex_declare_in_args(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe9ef
jmp 0xeaec
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x69, %eax
je 0xea0d
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0xeadb
movq -0x10(%rbp), %rax
cmpl $0x13, 0x20(%rax)
je 0xeadb
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe790
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xcc60
testb $0x1, %al
jne 0xea55
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xcc90
testb $0x1, %al
jne 0xea55
movq -0x10(%rbp), %rax
cmpl $0x9, 0x20(%rax)
jne 0xeab2
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcc4e(%rip), %rsi      # 0x1b6c3
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
movsbl 0x9(%rax), %eax
cmpl $0x67, %eax
jne 0xeab0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcc43(%rip), %rsi      # 0x1b6e5
leaq 0xcc69(%rip), %rdx      # 0x1b712
movb $0x0, %al
callq 0x33a0
jmp 0xead9
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcc51(%rip), %rsi      # 0x1b723
movb $0x0, %al
callq 0x33a0
jmp 0xeadb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xe9d0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_out_args(_IO_FILE*, Var*)
void mex_declare_out_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->iospec == 'o' && v->tinfo != VT_mx) {
        char typebuf[128];
        mex_declare_type(typebuf, v);
        if (is_array(v->tinfo) || is_obj(v->tinfo) || v->tinfo == VT_string) {
            fprintf(fp, "    %-10s  out%d_=0; /* %-10s */\n",
                    typebuf, v->output_label, v->name);
            if(v->devicespec == 'g'){
                fprintf(fp, "    %-10s *mxGPUArray_out%d_ =0; /* %-10s */\n",
                       "mxGPUArray", v->output_label, v->name);
                fprintf(fp, "    %-10s gpu_outdims%d_[2] = {0,0}; /* %-10s dims*/\n",
                       "mwSize", v->output_label, v->name);
            }
        } else {
            fprintf(fp, "    %-10s  out%d_;   /* %-10s */\n",
                    typebuf, v->output_label, v->name);
        }
    }
    mex_declare_out_args(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xeb1f
jmp 0xec3e
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
jne 0xec2d
movq -0x10(%rbp), %rax
cmpl $0xa, 0x20(%rax)
je 0xec2d
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe790
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xcc60
testb $0x1, %al
jne 0xeb7c
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xcc90
testb $0x1, %al
jne 0xeb7c
movq -0x10(%rbp), %rax
cmpl $0x9, 0x20(%rax)
jne 0xec03
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcba8(%rip), %rsi      # 0x1b745
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
movsbl 0x9(%rax), %eax
cmpl $0x67, %eax
jne 0xec01
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcb9c(%rip), %rsi      # 0x1b767
leaq 0xcbc3(%rip), %rdx      # 0x1b795
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcbad(%rip), %rsi      # 0x1b7a0
leaq 0xcbdc(%rip), %rdx      # 0x1b7d6
movb $0x0, %al
callq 0x33a0
jmp 0xec2b
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
leaq 0xcbb9(%rip), %rsi      # 0x1b7dd
movb $0x0, %al
callq 0x33a0
jmp 0xec2d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xeb00
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_dim_args(_IO_FILE*, Expr*)
void mex_declare_dim_args(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, "    %-10s  dim%d_;   /* %-10s */\n",
            "mwSize", e->input_label, e->value);
    mex_declare_dim_args(fp, e->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xec69
jmp 0xeca1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0xcb7d(%rip), %rsi      # 0x1b7ff
leaq 0xcb4d(%rip), %rdx      # 0x1b7d6
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xec50
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_dim_args(_IO_FILE*, Var*)
void mex_declare_dim_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->qual)
        mex_declare_dim_args(fp, v->qual->args);
    mex_declare_dim_args(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xecc9
jmp 0xecfa
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xece9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xec50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xecb0
addq $0x10, %rsp
popq %rbp
retq
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_args(_IO_FILE*, Func*)
void mex_declare_args(FILE* fp, Func* f)
{
    if (f->thisv) {
        char typebuf[128];
        strcpy(typebuf, f->classv);
        strcat(typebuf, "*");
        fprintf(fp, "    %-10s  in%d_ =0; /* %-10s */\n",
                typebuf, 0, f->thisv);
    }
    mex_declare_in_args(fp, f->args);
    if (!nullable_return(f))
        mex_declare_return(fp, f->ret);
    mex_declare_out_args(fp, f->args);
    mex_declare_dim_args(fp, f->ret);
    mex_declare_dim_args(fp, f->args);
    if (f->ret || f->args || f->thisv)
        fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xed98
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x3200
leaq -0x90(%rbp), %rdi
leaq 0xc900(%rip), %rsi      # 0x1b670
callq 0x3430
movq -0x8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %r8
leaq 0xc934(%rip), %rsi      # 0x1b6c3
xorl %ecx, %ecx
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xe9d0
movq -0x10(%rbp), %rdi
callq 0xccc0
testb $0x1, %al
jne 0xedc7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xed00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xeb00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xecb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xecb0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xee1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xee1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xee2d
movq -0x8(%rbp), %rdi
leaq 0xc33c(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_unpack_dims(_IO_FILE*, Expr*)
int mex_unpack_dims(FILE* fp, Expr* e)
{
    if (!e)
        return 0;
    fprintf(fp,
            "    dim%d_ = (mwSize) mxWrapGetScalar(prhs[%d], &mw_err_txt_);\n",
            e->input_label, e->input_label);
    return mex_unpack_dims(fp, e->next)+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xee60
movl $0x0, -0x4(%rbp)
jmp 0xee95
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
leaq 0xc9aa(%rip), %rsi      # 0x1b821
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xee40
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_unpack_dims(_IO_FILE*, Var*)
int mex_unpack_dims(FILE* fp, Var* v)
{
    if (!v)
        return 0;
    if (v->qual)
        return
            mex_unpack_dims(fp, v->qual->args) +
            mex_unpack_dims(fp, v->next);
    return mex_unpack_dims(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xeec0
movl $0x0, -0x4(%rbp)
jmp 0xef14
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xef00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xee40
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xeea0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xef14
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xeea0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_check_dims(_IO_FILE*, Var*)
void mex_check_dims(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->iospec != 'o' && is_array(v->tinfo) && v->qual && v->qual->args && v->devicespec != 'g') {
        Expr* a = v->qual->args;
        if (a->next) {
            fprintf(fp,
                    "    if (mxGetM(prhs[%d]) != dim%d_ ||\n"
                    "        mxGetN(prhs[%d]) != dim%d_) {\n"
                    "        mw_err_txt_ = \"Bad argument size: %s\";\n"
                    "        goto mw_err_label;\n"
                    "    }\n\n",
                    v->input_label, a->input_label,
                    v->input_label, a->next->input_label,
                    v->name);
        } else {
            fprintf(fp,
                    "    if (mxGetM(prhs[%d])*mxGetN(prhs[%d]) != dim%d_) {\n"
                    "        mw_err_txt_ = \"Bad argument size: %s\";"
                    "        goto mw_err_label;\n"
                    "    }\n\n",
                    v->input_label, v->input_label, a->input_label,
                    v->name);
        }
    }
    mex_check_dims(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xef9c
jmp 0xf08e
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
je 0xf07d
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xcc60
testb $0x1, %al
jne 0xefc2
jmp 0xf07d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf07d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xf07d
movq -0x10(%rbp), %rax
movsbl 0x9(%rax), %eax
cmpl $0x67, %eax
je 0xf07d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf04e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl (%rax), %r8d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %r9d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0xc820(%rip), %rsi      # 0x1b861
movq %rax, (%rsp)
movb $0x0, %al
callq 0x33a0
jmp 0xf07b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r9
leaq 0xc88b(%rip), %rsi      # 0x1b8ff
movb $0x0, %al
callq 0x33a0
jmp 0xf07d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xef80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_alloc_size1(_IO_FILE*, Expr*)
void mex_alloc_size1(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, "dim%d_", e->input_label);
    if (e->next) {
        fprintf(fp, "*");
        mex_alloc_size1(fp, e->next);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf0e9
jmp 0xf12f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0xdb9f(%rip), %rsi      # 0x1cc99
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf12f
movq -0x8(%rbp), %rdi
leaq 0xc559(%rip), %rsi      # 0x1b670
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xf0d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_unpack_input_string(_IO_FILE*, Var*)
void mex_unpack_input_string(FILE* fp, Var* v)
{
    if (!(v->qual && v->qual->args))
        fprintf(fp,
                "    in%d_ = mxWrapGetString(prhs[%d], &mw_err_txt_);\n"
                "    if (mw_err_txt_)\n"
                "        goto mw_err_label;\n",
                v->input_label, v->input_label);
    else {
        fprintf(fp, "    in%d_ = (char*) mxMalloc(",
                v->input_label);
        mex_alloc_size(fp, v->qual->args);
        fprintf(fp, "*sizeof(char));\n");
        fprintf(fp, "    if (mxGetString(prhs[%d], in%d_, ",
                v->input_label, v->input_label);
        mex_alloc_size(fp, v->qual->args);
        fprintf(fp, ") != 0) {\n"
                "        mw_err_txt_ = \"Invalid string argument\";\n"
                "        goto mw_err_label;\n"
                "    }\n");
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf48a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0xf4ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0xcb10(%rip), %rsi      # 0x1bfb1
movb $0x0, %al
callq 0x33a0
jmp 0xf531
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0xcb59(%rip), %rsi      # 0x1c017
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xf140
movq -0x8(%rbp), %rdi
leaq 0xcb50(%rip), %rsi      # 0x1c035
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0xcb43(%rip), %rsi      # 0x1c046
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xf140
movq -0x8(%rbp), %rdi
leaq 0xcb42(%rip), %rsi      # 0x1c06c
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
leaq 0xbc26(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_check_inputs(_IO_FILE*, Var*)
void mex_check_inputs(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->iospec != 'o' && (v->tinfo == VT_obj || v->tinfo == VT_r_obj))
        fprintf(fp,
                "    if (!in%d_) {\n"
                "        mw_err_txt_ = \"Argument %s cannot be null\";\n"
                "        goto mw_err_label;\n"
                "    }\n",
                v->input_label, v->name);
    mex_check_inputs(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf879
jmp 0xf8cb
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
je 0xf8ba
movq -0x10(%rbp), %rax
cmpl $0x1, 0x20(%rax)
je 0xf89a
movq -0x10(%rbp), %rax
cmpl $0xf, 0x20(%rax)
jne 0xf8ba
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0xcd13(%rip), %rsi      # 0x1c5c6
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xf860
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_make_call(_IO_FILE*, Var*, int)
void mex_make_call(FILE* fp, Var* v, int first)
{
    if (!v)
        return;
    if (!first)
        fprintf(fp, ", ");

    char namebuf[128];
    if (v->tinfo == VT_obj || v->tinfo == VT_r_obj)
        fprintf(fp, "*%s", vname(v, namebuf));
    else if (v->tinfo == VT_mx && v->iospec == 'o')
        fprintf(fp, "plhs+%d", v->output_label);
    else if (v->tinfo == VT_p_scalar ||
             v->tinfo == VT_p_cscalar ||
             v->tinfo == VT_p_zscalar)
        fprintf(fp, "&%s", vname(v, namebuf));
    else if (v->tinfo == VT_const)
        fprintf(fp, "%s", v->name);
    else
        fprintf(fp, "%s", vname(v, namebuf));
    mex_make_call(fp, v->next, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfcb2
jmp 0xfe10
cmpl $0x0, -0x14(%rbp)
jne 0xfcca
movq -0x8(%rbp), %rdi
leaq 0xcdff(%rip), %rsi      # 0x1cac2
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x20(%rax)
je 0xfcde
movq -0x10(%rbp), %rax
cmpl $0xf, 0x20(%rax)
jne 0xfd16
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xcd60
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
leaq 0xcae9(%rip), %rsi      # 0x1c7f3
movb $0x0, %al
callq 0x33a0
jmp 0xfdfd
movq -0x10(%rbp), %rax
cmpl $0xa, 0x20(%rax)
jne 0xfd4b
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
jne 0xfd4b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xcab8(%rip), %rsi      # 0x1c7f7
movb $0x0, %al
callq 0x33a0
jmp 0xfdfb
movq -0x10(%rbp), %rax
cmpl $0xc, 0x20(%rax)
je 0xfd69
movq -0x10(%rbp), %rax
cmpl $0xd, 0x20(%rax)
je 0xfd69
movq -0x10(%rbp), %rax
cmpl $0xe, 0x20(%rax)
jne 0xfd9e
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xcd60
movq -0xb0(%rbp), %rdi
movq %rax, %rdx
leaq 0xca6a(%rip), %rsi      # 0x1c7ff
movb $0x0, %al
callq 0x33a0
jmp 0xfdf9
movq -0x10(%rbp), %rax
cmpl $0x13, 0x20(%rax)
jne 0xfdc4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x51d6(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
jmp 0xfdf7
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xcd60
movq -0xb8(%rbp), %rdi
movq %rax, %rdx
leaq 0x51a1(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
jmp 0xfdf9
jmp 0xfdfb
jmp 0xfdfd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %edx, %edx
callq 0xfc90
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_make_call(_IO_FILE*, Func*)
void mex_make_call(FILE* fp, Func* f)
{
    if (f->thisv)
        fprintf(fp, "in0_->");
    if (strcmp(f->funcv, "new") == 0)
        fprintf(fp, "new %s(", f->classv);
    else {
        if (f->fort)
            fprintf(fp, "MWF77_");
        fprintf(fp, "%s(", f->funcv);
    }
    mex_make_call(fp, f->args, 1);
    fprintf(fp, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xfe4d
movq -0x8(%rbp), %rdi
leaq 0xc9bd(%rip), %rsi      # 0x1c803
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x4656(%rip), %rsi      # 0x144b2
callq 0x3390
cmpl $0x0, %eax
jne 0xfe82
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
leaq 0xca35(%rip), %rsi      # 0x1c8ae
movb $0x0, %al
callq 0x33a0
jmp 0xfeb8
movq -0x10(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0xfe9e
movq -0x8(%rbp), %rdi
leaq 0xc973(%rip), %rsi      # 0x1c80a
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xca01(%rip), %rsi      # 0x1c8b2
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movl $0x1, %edx
callq 0xfc90
movq -0x8(%rbp), %rdi
leaq 0xe747(%rip), %rsi      # 0x1e620
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_marshal_results(_IO_FILE*, Var*, bool)
void mex_marshal_results(FILE* fp, Var* v, bool return_flag)
{
    if (!v)
        return;
    if (v->iospec != 'i')
        mex_marshal_result(fp, v, return_flag);
    mex_marshal_results(fp, v->next, return_flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10f60
jmp 0x10f9b
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x69, %eax
je 0x10f82
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x10bc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x10f40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_c_comment(_IO_FILE*, Func*)
void print_c_comment(FILE* fp, Func* f)
{
    fprintf(fp, "/* ---- %s: %d ----\n * ", f->fname.c_str(), f->line);
    print(fp, f);
    for (Func* fsame = f->same_next; fsame; fsame = fsame->next)
        fprintf(fp, " * Also at %s: %d\n", fsame->fname.c_str(), fsame->line);
    fprintf(fp, " */\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
leaq 0xbdf8(%rip), %rsi      # 0x1d0ae
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x85d0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11318
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3100
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
leaq 0xbdc3(%rip), %rsi      # 0x1d0c6
movb $0x0, %al
callq 0x33a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x112d6
movq -0x8(%rbp), %rdi
leaq 0x9eeb(%rip), %rsi      # 0x1b20e
movb $0x0, %al
callq 0x33a0
addq $0x30, %rsp
popq %rbp
retq
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_stub(_IO_FILE*, Func*)
void print_mex_stub(FILE* fp, Func* f)
{
    print_c_comment(fp, f);
    fprintf(fp,
            "static const char* stubids%d_ = \"%s\";\n\n"
            "void mexStub%d(int nlhs, mxArray* plhs[],\n"
            "              int nrhs, const mxArray* prhs[])\n"
            "{\n"
            "    const char* mw_err_txt_ = 0;\n",
            f->id, id_string(f).c_str(), f->id);

    mex_declare_args(fp, f);
    mex_unpack_dims(fp, f);
    mex_check_dims(fp, f);
    mex_unpack_inputs(fp, f);
    mex_check_inputs(fp, f);
    mex_alloc_output(fp, f);
    mex_record_call(fp, f);
    mex_make_stmt(fp, f);
    mex_marshal_results(fp, f);
    fprintf(fp, "\nmw_err_label:\n");
    mex_dealloc(fp, f);
    fprintf(fp,
            "    if (mw_err_txt_)\n"
            "        mexErrMsgTxt(mw_err_txt_);\n"
            "}\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11280
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x8b40
leaq -0x30(%rbp), %rdi
callq 0x3100
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %r8d
leaq 0xbd4b(%rip), %rsi      # 0x1d0d9
movb $0x0, %al
callq 0x33a0
leaq -0x30(%rbp), %rdi
callq 0x34c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xed30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xef20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf0a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf8e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfc10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfc60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfef0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10fb0
movq -0x8(%rbp), %rdi
leaq 0xbd5f(%rip), %rsi      # 0x1d17d
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11230
movq -0x8(%rbp), %rdi
leaq 0xbd50(%rip), %rsi      # 0x1d18d
movb $0x0, %al
callq 0x33a0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: make_profile_output(_IO_FILE*, Func*, char const*)
void make_profile_output(FILE* fp, Func* f, const char* printfunc)
{
    fprintf(fp,
            "        if (!mexprofrecord_)\n"
            "            %s\"Profiler inactive\\n\");\n",
            printfunc);
    for (; f; f = f->next) {
        fprintf(fp, "        %s\"%%d calls to %s:%d",
                printfunc, f->fname.c_str(), f->line);
        for (Func* fsame = f->same_next; fsame; fsame = fsame->next)
            fprintf(fp, " (%s:%d)", fsame->fname.c_str(), fsame->line);
        fprintf(fp, "\\n\", mexprofrecord_[%d]);\n", f->id);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xbd56(%rip), %rsi      # 0x1d1c9
movb $0x0, %al
callq 0x33a0
cmpq $0x0, -0x10(%rbp)
je 0x11537
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %r8d
leaq 0xbd55(%rip), %rsi      # 0x1d20d
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1150d
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3100
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
leaq 0xbd33(%rip), %rsi      # 0x1d22b
movb $0x0, %al
callq 0x33a0
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x114cb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0xbd15(%rip), %rsi      # 0x1d234
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1147a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)