LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]HM3/hm3/main/db_lsmheat.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 1){
		printUsage(argv[0]);
		return 1;
	}

	// =======================

	const auto path		= argv[1];

	// =======================

	using DirectoryTableLoader = hm3::tableloader::DirectoryTableLoader;
	using MyLSMTable = hm3::LSMTable<DirectoryTableLoader::container_type>;

	DirectoryTableLoader dl{ path };
	MyLSMTable mtlist(*dl);

	// =======================

	// first key
	mtlist.begin();

	const char last[] = { (char) 0xFF, '\0' };

	// ~last key
	mtlist.lowerBound( last );

	return 0;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movl $0x0, 0x124(%rsp)
movl %edi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
cmpl $0x1, 0x120(%rsp)
jg 0x25db
movq 0x118(%rsp), %rax
movq (%rax), %rdi
callq 0x2700
movl $0x1, 0x124(%rsp)
jmp 0x26d9
movq 0x118(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2810
movq (%rsp), %rsi
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2860
movq 0x8(%rsp), %rdi
callq 0x28e0
movq %rax, 0x10(%rsp)
jmp 0x262f
movq 0x10(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x28f0
jmp 0x2643
leaq 0x70(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x2910
jmp 0x2657
leaq 0x70(%rsp), %rdi
callq 0x2940
movw $0xff, 0x6e(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x6e(%rsp), %rsi
callq 0x2810
jmp 0x2679
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x2970
jmp 0x2692
leaq 0x28(%rsp), %rdi
callq 0x2940
movl $0x0, 0x124(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x29b0
jmp 0x26d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x29b0
jmp 0x26e8
movl 0x124(%rsp), %eax
addq $0x128, %rsp            # imm = 0x128
retq
movq 0xb8(%rsp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/hm3/main/db_lsmheat.cc
// Function: printUsage(char const*)
static void printUsage(const char *cmd){
	std::cout
		<< "This program retrieve first and last element of each disktable from the LSM tree."	<< '\n'
		<< "It creates 'hotspots' into OS cache, so next searches to be fast."			<< '\n'
		<< '\n'

		<< "Usage:"	<< '\n'
		<< "\t"		<< cmd	<< "[lsm_path] - preload / heat lsm_path"	<< '\n'

		<< "\t\tPath names must be written without extention"		<< '\n'
		<< "\t\tExample 'directory/file.*'"				<< '\n'
		<< "\t\tExample 'directory/file.db'"				<< '\n'

		<< '\n';
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq 0x108c4(%rip), %rdi     # 0x12fd0
leaq 0xa8f3(%rip), %rsi      # 0xd006
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
leaq 0xa929(%rip), %rsi      # 0xd058
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
leaq 0xa942(%rip), %rsi      # 0xd09a
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
leaq 0xa92d(%rip), %rsi      # 0xd0a1
callq 0x2200
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x2200
movq %rax, %rdi
leaq 0xa914(%rip), %rsi      # 0xd0a3
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
leaq 0xa91d(%rip), %rsi      # 0xd0c8
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
leaq 0xa930(%rip), %rsi      # 0xd0f7
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
leaq 0xa931(%rip), %rsi      # 0xd114
callq 0x2200
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
movq %rax, %rdi
movl $0xa, %esi
callq 0x2260
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: init_scalar_types()
void init_scalar_types()
{
    const char* scalar_types[] = {
        "double", "float", 
        "long", "int", "short", "char", 
        "ulong", "uint", "ushort", "uchar",
	"int32_t", "int64_t", "uint32_t", "uint64_t",
        "bool", "size_t", "ptrdiff_t", NULL};

    for (const char** s = scalar_types; *s; ++s)
        add_scalar_type(*s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x90(%rbp), %rdi
leaq 0x1d537(%rip), %rsi     # 0x24d10
movl $0x90, %edx
callq 0x31c0
leaq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7821
movq -0x98(%rbp), %rax
movq (%rax), %rdi
callq 0x7830
movq -0x98(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
jmp 0x77f1
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, Expr*)
void print(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, "%s", e->value);
    if (e->next) {
        fprintf(fp, ", ");
        print(fp, e->next);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8379
jmp 0x83c1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xcc05(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x83c1
movq -0x8(%rbp), %rdi
leaq 0x14719(%rip), %rsi     # 0x1cac2
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x8360
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, TypeQual*)
void print(FILE* fp, TypeQual* q)
{
    if (!q)
        return;
    if (q->qual == 'a') {
        fprintf(fp, "[");
        print(fp, q->args);
        fprintf(fp, "]");
    } else
        fprintf(fp, "%c", q->qual);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x83e9
jmp 0x8445
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x842c
movq -0x8(%rbp), %rdi
leaq 0xc769(%rip), %rsi      # 0x14b69
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x8360
movq -0x8(%rbp), %rdi
leaq 0xc748(%rip), %rsi      # 0x14b6b
movb $0x0, %al
callq 0x33a0
jmp 0x8445
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
leaq 0xc72f(%rip), %rsi      # 0x14b6d
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print_iospec(_IO_FILE*, Var*)
void print_iospec(FILE* fp, Var* v)
{
    if (v->iospec == 'o')
        fprintf(fp, "output ");
    else if (v->iospec == 'b')
        fprintf(fp, "inout ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
jne 0x84c1
movq -0x8(%rbp), %rdi
leaq 0xc6bd(%rip), %rsi      # 0x14b75
movb $0x0, %al
callq 0x33a0
jmp 0x84e2
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0x84e0
movq -0x8(%rbp), %rdi
leaq 0xc6a4(%rip), %rsi      # 0x14b7d
movb $0x0, %al
callq 0x33a0
jmp 0x84e2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print_args(_IO_FILE*, Var*)
void print_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    print_devicespec(fp, v);
    print_iospec(fp, v);
    print_var(fp, v);
    if (v->next) {
        fprintf(fp, ", ");
        print_args(fp, v->next);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8569
jmp 0x85be
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8490
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x84f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x85be
movq -0x8(%rbp), %rdi
leaq 0x1451c(%rip), %rsi     # 0x1cac2
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x8550
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, Func*)
void print(FILE* fp, Func* f)
{
    if (!f)
        return;
    if (f->ret) {
        print_var(fp, f->ret);
        fprintf(fp, " = ");
    }
    if (f->thisv)
        fprintf(fp, "%s->%s.", f->thisv, f->classv);
    fprintf(fp, "%s(", f->funcv);
    print_args(fp, f->args);
    fprintf(fp, ");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x85ec
jmp 0x8684
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x861a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x84f0
movq -0x8(%rbp), %rdi
leaq 0x1430a(%rip), %rsi     # 0x1c91d
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8647
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
leaq 0xc544(%rip), %rsi      # 0x14b84
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x14258(%rip), %rsi     # 0x1c8b2
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x8550
movq -0x8(%rbp), %rdi
leaq 0x1518c(%rip), %rsi     # 0x1d809
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](TypeQual*)
string id_string(TypeQual* q)
{
    if (!q)
        return "";
    if (q->qual == 'a')
        return "[" + id_string(q->args) + "]";
    else
        return (string() + q->qual);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x87df
leaq -0x11(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3420
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq 0x129b3(%rip), %rsi     # 0x1b163
callq 0x9150
jmp 0x87b7
leaq -0x11(%rbp), %rdi
callq 0x32a0
jmp 0x88d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x32a0
jmp 0x88e5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x887e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x8690
movq -0xa8(%rbp), %rdx
leaq 0xc354(%rip), %rsi      # 0x14b69
leaq -0x48(%rbp), %rdi
callq 0x9330
jmp 0x8820
movq -0x98(%rbp), %rdi
leaq 0xc33d(%rip), %rdx      # 0x14b6b
leaq -0x48(%rbp), %rsi
callq 0x9380
jmp 0x8839
leaq -0x48(%rbp), %rdi
callq 0x34c8
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0x88d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x8873
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x34c8
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0x88e5
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3380
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
callq 0x93d0
jmp 0x88ad
leaq -0x88(%rbp), %rdi
callq 0x34c8
jmp 0x88d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x34c8
jmp 0x88e5
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3410
nop
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](Func*)
string id_string(Func* f)
{
    if (!f)
        return "";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8bb0
leaq -0x11(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3420
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq 0x125e2(%rip), %rsi     # 0x1b163
callq 0x9150
jmp 0x8b88
leaq -0x11(%rbp), %rdi
callq 0x32a0
jmp 0x8d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x32a0
jmp 0x8d31
movq -0x78(%rbp), %rdi
movb $0x0, -0x25(%rbp)
callq 0x3380
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x8c32
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x88f0
jmp 0x8bdb
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3340
jmp 0x8bea
leaq -0x48(%rbp), %rdi
callq 0x34c8
movq -0x78(%rbp), %rdi
leaq 0x13d1f(%rip), %rsi     # 0x1c91d
callq 0x3210
jmp 0x8c05
jmp 0x8c32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x8d19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x34c8
jmp 0x8d19
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8c89
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x3210
jmp 0x8c50
movq -0x78(%rbp), %rdi
leaq 0x13bac(%rip), %rsi     # 0x1c807
callq 0x3210
jmp 0x8c62
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x3210
jmp 0x8c75
movq -0x78(%rbp), %rdi
leaq 0xbf0a(%rip), %rsi      # 0x14b8a
callq 0x3210
jmp 0x8c87
jmp 0x8c89
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x3210
jmp 0x8c9c
movq -0x78(%rbp), %rdi
leaq 0x13cad(%rip), %rsi     # 0x1c954
callq 0x3210
jmp 0x8cae
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0x88f0
jmp 0x8cc1
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3340
jmp 0x8cd0
leaq -0x68(%rbp), %rdi
callq 0x34c8
movq -0x78(%rbp), %rdi
leaq 0x1593c(%rip), %rsi     # 0x1e620
callq 0x3210
jmp 0x8ceb
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x8d17
jmp 0x8d0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0x8d19
movq -0x78(%rbp), %rdi
callq 0x34c8
jmp 0x8d24
movq -0x78(%rbp), %rdi
callq 0x34c8
jmp 0x8d31
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Expr*)
void destroy(Expr* e)
{
    if (!e)
        return;
    destroy(e->next);
    delete[] e->value;
    delete e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8d55
jmp 0x8d99
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8d40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8d7d
movq -0x10(%rbp), %rdi
callq 0x3350
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8d99
movq -0x18(%rbp), %rdi
movl $0x18, %esi
callq 0x3240
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(TypeQual*)
void destroy(TypeQual* q)
{
    if (!q)
        return;
    destroy(q->args);
    delete q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8db5
jmp 0x8dde
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8d40
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8dde
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Var*)
void destroy(Var* v)
{
    if (!v) 
        return;
    destroy(v->next);
    destroy(v->qual);
    delete[] v->basetype;
    delete[] v->name;
    delete v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8e05
jmp 0x8e71
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x8df0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8da0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8e3a
movq -0x10(%rbp), %rdi
callq 0x3350
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8e55
movq -0x18(%rbp), %rdi
callq 0x3350
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8e71
movq -0x20(%rbp), %rdi
movl $0x38, %esi
callq 0x3240
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Func*)
void destroy(Func* f)
{
    while (f) {
        Func* oldf = f;
        f = f->next;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8f67
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x8e80
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x8df0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x8eed
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8eeb
movq -0x18(%rbp), %rdi
callq 0x3350
jmp 0x8eed
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x8f15
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8f13
movq -0x20(%rbp), %rdi
callq 0x3350
jmp 0x8f15
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8f30
movq -0x28(%rbp), %rdi
callq 0x3350
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x8df0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8f62
movq -0x30(%rbp), %rdi
callq 0x9420
movq -0x30(%rbp), %rdi
movl $0x68, %esi
callq 0x3240
jmp 0x8e8c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(InheritsDecl*)
void destroy(InheritsDecl* i)
{
    if (!i)
        return;
    destroy(i->next);
    delete i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8f85
jmp 0x8fae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8f70
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8fae
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy_inherits()
void destroy_inherits()
{
    map<string,InheritsDecl*>::iterator i = class_decls.begin();
    for (; i != class_decls.end(); ++i) {
        destroy(i->second);
        i->second = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1c519(%rip), %rdi     # 0x254e8
callq 0x9440
movq %rax, -0x8(%rbp)
leaq 0x1c509(%rip), %rdi     # 0x254e8
callq 0x94a0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9470
testb $0x1, %al
jne 0x8ffb
jmp 0x9029
leaq -0x8(%rbp), %rdi
callq 0x94d0
movq 0x20(%rax), %rdi
callq 0x8f70
leaq -0x8(%rbp), %rdi
callq 0x94d0
movq $0x0, 0x20(%rax)
leaq -0x8(%rbp), %rdi
callq 0x94f0
jmp 0x8fd8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_dim_args(Expr*, int&)
void label_dim_args(Expr* e, int& icount)
{
    if (!e)
        return;
    e->input_label = icount++;
    label_dim_args(e->next, icount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb5d9
jmp 0xb5fd
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, (%rax)
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb5c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb629
jmp 0xb65a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb649
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb5c0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb610
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb67d
jmp 0xb6ed
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x69, %eax
je 0xb697
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0xb6aa
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, (%rax)
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
je 0xb6c4
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0xb6d8
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, (%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb660
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xb72c
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xb660
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xb660
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0xb610
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0xb610
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb962
movl $0x0, -0x4(%rbp)
jmp 0xb9fa
movq -0x10(%rbp), %rax
cmpl $0x7, 0x20(%rax)
je 0xb976
movq -0x10(%rbp), %rax
cmpl $0x8, 0x20(%rax)
jne 0xb9ab
movq 0x1965b(%rip), %rax     # 0x24fd8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x928f(%rip), %rsi      # 0x14c19
movb $0x0, %al
callq 0x33a0
movq 0x19640(%rip), %rax     # 0x24fd8
movq (%rax), %rdi
leaq 0x92ad(%rip), %rsi      # 0x14c4f
movb $0x0, %al
callq 0x33a0
jmp 0xb9f3
movq -0x10(%rbp), %rax
cmpl $0x6, 0x20(%rax)
je 0xb9f1
movq 0x1961c(%rip), %rax     # 0x24fd8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x91fa(%rip), %rsi      # 0x14bc3
movb $0x0, %al
callq 0x33a0
movq 0x19601(%rip), %rax     # 0x24fd8
movq (%rax), %rdi
leaq 0x9295(%rip), %rsi      # 0x14c76
movb $0x0, %al
callq 0x33a0
movl $0x1, -0x4(%rbp)
jmp 0xb9fa
jmp 0xb9f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x24(%rax)
jne 0xba32
movl $0x0, -0x4(%rbp)
jmp 0xba5f
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xb780
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xb940
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb700
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xc100
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xc2c0
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xba10
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: has_output_args(Var*)
int has_output_args(Var* v)
{
    if (!v)
        return 0;
    if (v->iospec == 'o' || v->iospec == 'b')
        return 1;
    else 
        return has_output_args(v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc70c
movl $0x0, -0x4(%rbp)
jmp 0xc73f
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
je 0xc726
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0xc72f
movl $0x1, -0x4(%rbp)
jmp 0xc73f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xc6f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc76d
jmp 0xc7db
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
je 0xc787
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0xc7c6
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc7a2
movq -0x8(%rbp), %rdi
leaq 0x10327(%rip), %rsi     # 0x1cac2
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x87dc(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc750
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc809
jmp 0xc86e
movq -0x10(%rbp), %rax
cmpl $0x13, 0x20(%rax)
jne 0xc827
movq -0x8(%rbp), %rdi
leaq 0x876d(%rip), %rsi      # 0x14f8b
movb $0x0, %al
callq 0x33a0
jmp 0xc85d
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x69, %eax
je 0xc841
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x62, %eax
jne 0xc85b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x873b(%rip), %rsi      # 0x14f8f
movb $0x0, %al
callq 0x33a0
jmp 0xc85d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xc7f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_dimension_args(_IO_FILE*, Expr*)
void print_dimension_args(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, ", %s", e->value);
    print_dimension_args(fp, e->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc899
jmp 0xc8c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x86e3(%rip), %rsi      # 0x14f8f
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xc880
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc8e9
jmp 0xc91a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc909
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xc880
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xc8d0
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8b40
leaq -0x38(%rbp), %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x8634(%rip), %rsi      # 0x14f94
movb $0x0, %al
callq 0x33a0
leaq -0x38(%rbp), %rdi
callq 0x34c8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xc98d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xc6f0
cmpl $0x0, %eax
je 0xc9e2
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x81ca(%rip), %rsi      # 0x14b69
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xc750
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xc750
movq -0x8(%rbp), %rdi
leaq 0xff41(%rip), %rsi      # 0x1c91c
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x85b4(%rip), %rsi      # 0x14fa5
movb $0x0, %al
callq 0x33a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xca1d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x8579(%rip), %rsi      # 0x14f8f
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xc7f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rdi
leaq 0x10dae(%rip), %rsi     # 0x1d809
movb $0x0, %al
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x803b(%rip), %rsi      # 0x14b42
callq 0x3390
cmpl $0x0, %eax
jne 0xcb26
leaq 0xdf23(%rip), %rdi      # 0x1aa3b
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x801a(%rip), %rsi      # 0x14b4b
callq 0x3390
cmpl $0x0, %eax
jne 0xcb50
leaq 0xdf07(%rip), %rdi      # 0x1aa49
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x7fe6(%rip), %rsi      # 0x14b41
callq 0x3390
cmpl $0x0, %eax
jne 0xcb7a
leaq 0xdeeb(%rip), %rdi      # 0x1aa57
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x7fc5(%rip), %rsi      # 0x14b4a
callq 0x3390
cmpl $0x0, %eax
jne 0xcba4
leaq 0xded0(%rip), %rdi      # 0x1aa66
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x7f74(%rip), %rsi      # 0x14b23
callq 0x3390
cmpl $0x0, %eax
jne 0xcbce
leaq 0xdeb5(%rip), %rdi      # 0x1aa75
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x78ac(%rip), %rsi      # 0x14485
callq 0x3390
cmpl $0x0, %eax
jne 0xcbf5
leaq 0xde8b(%rip), %rdi      # 0x1aa75
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x7f1c(%rip), %rsi      # 0x14b1c
callq 0x3390
cmpl $0x0, %eax
jne 0xcc1c
leaq 0xde73(%rip), %rdi      # 0x1aa84
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
movq -0x10(%rbp), %rdi
leaq 0x7855(%rip), %rsi      # 0x1447c
callq 0x3390
cmpl $0x0, %eax
jne 0xcc43
leaq 0xde4c(%rip), %rdi      # 0x1aa84
callq 0x3460
movq %rax, -0x8(%rbp)
jmp 0xcc53
leaq 0xde49(%rip), %rdi      # 0x1aa93
callq 0x3460
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, -0x9(%rbp)
je 0xcd49
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movb $0x1, %al
cmpl $0x9, 0x20(%rcx)
movb %al, -0xa(%rbp)
je 0xcd43
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movl 0x20(%rax), %edi
callq 0xcc60
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xa(%rbp)
jne 0xcd43
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movb $0x1, %al
cmpl $0xc, 0x20(%rcx)
movb %al, -0xa(%rbp)
je 0xcd43
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movb $0x1, %al
cmpl $0xd, 0x20(%rcx)
movb %al, -0xa(%rbp)
je 0xcd43
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0xe, 0x20(%rax)
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x6f, %eax
jne 0xcd98
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xdd11(%rip), %rsi      # 0x1aaa0
movb $0x0, %al
callq 0x30a0
jmp 0xcdb0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0xdcfe(%rip), %rsi      # 0x1aaa7
movb $0x0, %al
callq 0x30a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcdef
movq -0x10(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0xcddf
movb $0x1, -0x1(%rbp)
jmp 0xcdf3
jmp 0xcde1
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcdc8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: complex_tinfo(Var*)
bool complex_tinfo(Var* v)
{
    return (v->tinfo == VT_carray || v->tinfo == VT_zarray ||
            v->tinfo == VT_cscalar || v->tinfo == VT_zscalar ||
            v->tinfo == VT_r_cscalar || v->tinfo == VT_r_zscalar ||
            v->tinfo == VT_p_cscalar || v->tinfo == VT_p_zscalar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x3, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x4, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x7, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x8, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x11, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x12, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0xd, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0xce7f
movq -0x8(%rbp), %rax
cmpl $0xe, 0x20(%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcecc
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0xcebc
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0xcebe
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xce9f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xde89(%rip), %rsi      # 0x1b160
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
leaq 0xde7b(%rip), %rsi      # 0x1b164
movb $0x0, %al
callq 0x33a0
leaq 0x18221(%rip), %rdi     # 0x25518
callq 0x11810
movq %rax, -0x10(%rbp)
leaq 0x18211(%rip), %rdi     # 0x25518
callq 0x9300
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9290
testb $0x1, %al
jne 0xd323
jmp 0xd353
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x11840
movq %rax, %rdi
callq 0x3100
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xcfa0
leaq -0x10(%rbp), %rdi
callq 0x11870
jmp 0xd300
leaq 0x181ee(%rip), %rdi     # 0x25548
callq 0x11810
movq %rax, -0x20(%rbp)
leaq 0x181de(%rip), %rdi     # 0x25548
callq 0x9300
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9290
testb $0x1, %al
jne 0xd386
jmp 0xd3bd
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11840
movq %rax, %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
movq %rax, %rsi
leaq 0x7776(%rip), %rdx      # 0x14b23
callq 0xd190
leaq -0x20(%rbp), %rdi
callq 0x11870
jmp 0xd363
leaq 0x181b4(%rip), %rdi     # 0x25578
callq 0x11810
movq %rax, -0x30(%rbp)
leaq 0x181a4(%rip), %rdi     # 0x25578
callq 0x9300
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9290
testb $0x1, %al
jne 0xd3f0
jmp 0xd427
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11840
movq %rax, %rdi
callq 0x3100
movq -0x50(%rbp), %rdi
movq %rax, %rsi
leaq 0x7705(%rip), %rdx      # 0x14b1c
callq 0xd190
leaq -0x30(%rbp), %rdi
callq 0x11870
jmp 0xd3cd
movq -0x8(%rbp), %rdi
leaq 0xdd30(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xdd21(%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 0xd4a4
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x3470
movl %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x3330
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd476
movq -0x8(%rbp), %rdi
leaq 0xdcb3(%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_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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9200
cmpq $0x0, -0x10(%rbp)
je 0xd703
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 0xd58e
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 0xd543
movb $0x1, -0x7d(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x92c0
movq %rax, -0xe0(%rbp)
jmp 0xd55d
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 0xd5a2
jmp 0xd5ab
leaq -0x68(%rbp), %rdi
callq 0x34c8
testb $0x1, -0x6a(%rbp)
jne 0xd5b3
jmp 0xd5bc
leaq -0x69(%rbp), %rdi
callq 0x32a0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xd5cb
jmp 0xd6f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd440
jmp 0xd5da
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 0xd618
leaq -0x40(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x9240
movb %dl, -0x101(%rbp)
movq %rax, -0x100(%rbp)
jmp 0xd637
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 0xd6f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd69b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0xd690
jmp 0xd699
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0xd69b
testb $0x1, -0x6a(%rbp)
jne 0xd6a3
jmp 0xd6ac
leaq -0x69(%rbp), %rdi
callq 0x32a0
jmp 0xd715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd6e2
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 0xd715
jmp 0xd6f2
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd4dc
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_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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0xda31(%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 0xd794
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 0xd766
movq -0x8(%rbp), %rdi
leaq 0xd9f8(%rip), %rsi      # 0x1b197
movb $0x0, %al
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)