LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/slafi[P]EventSystem/EventSystem/src/event_args.cpp
// Function: Events::EventArgs::EventArgs(int, std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
EventArgs::EventArgs(int event_type, std::map<int, string>* args)
	{
		set_event_type(event_type);
		set_args(args);
		
		// Assign timestamp automatically
		set_timestamp(format_timestamp());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x10(%rdi), %rbx
movb $0x0, 0x20(%rdi)
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq -0x30(%rbp), %rdi
callq 0x3b42
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x20d0
leaq -0x30(%rbp), %rdi
callq 0x2090
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2090
jmp 0x3ad2
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/slafi[P]EventSystem/EventSystem/src/utils.cpp
// Function: Events::format_timestamp[abi:cxx11]()
std::string format_timestamp()
	{
		time_t rawtime;
		struct tm * timeInfo;
		char buffer[80];

		time(&rawtime);
		timeInfo = localtime(&rawtime);

		strftime(buffer, sizeof(buffer), "%d-%m-%Y %H:%M:%S", timeInfo);
		std::string str(buffer);

		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x2180
movq %r14, %rdi
callq 0x2120
leaq 0x743(%rip), %rdx       # 0x42ae
leaq -0x70(%rbp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0x2140
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b7a
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]Ticket-Booking-Service/client/ClientSocket.cpp
// Function: ClientSocket::Init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&)
void ClientSocket::Init(const std::string &ipaddress, const int &port) {

    if((mSockfd = socket(AF_INET, SOCK_STREAM, 0))<0) {
        std::cout << "Socket creation error" << std::endl;
        return;
    }
    memset(&mAddress, '0', sizeof(mAddress));

    mAddress.sin_family = AF_INET;
    mAddress.sin_port = htons(port);

    if(inet_pton(AF_INET, ipaddress.c_str(), &mAddress.sin_addr)<=0) {
        std::cout << "Invalid address/ Address not supported" << std::endl;
        return;
    }

    if(connect(mSockfd, (struct sockaddr *)&mAddress, sizeof(mAddress))<0) {
        std::cout << "Connection Failed" << std::endl;
        return;
    }

    mValid = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2050
movl %eax, 0x4(%rbx)
testl %eax, %eax
js 0x24be
movaps 0x1b9c(%rip), %xmm0     # 0x4010
movups %xmm0, 0xc(%rbx)
movw $0x2, 0xc(%rbx)
movzwl (%r15), %eax
rolw $0x8, %ax
movw %ax, 0xe(%rbx)
movq (%r14), %rsi
leaq 0x10(%rbx), %rdx
pushq $0x2
popq %rdi
callq 0x2240
testl %eax, %eax
jle 0x24ce
leaq 0xc(%rbx), %rsi
movl 0x4(%rbx), %edi
pushq $0x10
popq %rdx
callq 0x2130
testl %eax, %eax
js 0x24de
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3b0b(%rip), %rdi      # 0x5fd0
leaq 0x1b54(%rip), %rsi      # 0x4020
jmp 0x24ec
movq 0x3afb(%rip), %rdi      # 0x5fd0
leaq 0x1b5a(%rip), %rsi      # 0x4036
jmp 0x24ec
movq 0x3aeb(%rip), %rdi      # 0x5fd0
leaq 0x1b71(%rip), %rsi      # 0x405d
callq 0x2180
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]Ticket-Booking-Service/client/ClientSocket.cpp
// Function: ClientSocket::RequestTicket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ClientSocket::RequestTicket(const std::string &message) {

    //  Delay 5 second to simulate the time for message passing
    std::cout << "Request send" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    send(mSockfd, message.c_str(), message.length(), 0);

    mValread = read(mSockfd, buffer, 1024);
    std::cout << buffer << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x3aad(%rip), %r14      # 0x5fd0
leaq 0x1b45(%rip), %rsi      # 0x406f
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq -0x20(%rbp), %rdi
movq $0x5, (%rdi)
callq 0x259e
movl 0x4(%rbx), %edi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
xorl %ecx, %ecx
callq 0x20d0
movl 0x4(%rbx), %edi
leaq 0x1c(%rbx), %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
callq 0x21e0
movl %eax, 0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]Ticket-Booking-Service/client/UserInterface.cpp
// Function: UserInterface::UserInterface()
UserInterface::UserInterface() {

    std::cout << "==================================================" << std::endl;
    std::cout << "||"
              << std::setw(30) << std::right << "User Interface" 
              << std::setw(18) << std::right << "||" << std::endl;
    std::cout << "==================================================" << std::endl;

    mQuit = false;
    mServers = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movq 0x39d0(%rip), %rdi      # 0x5fd0
leaq 0x1a75(%rip), %rsi      # 0x407c
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq 0x39b5(%rip), %rdi      # 0x5fd0
leaq 0x1a8d(%rip), %rsi      # 0x40af
callq 0x2180
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x1e, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0xffffff4f, %r15d      # imm = 0xFFFFFF4F
movl 0x18(%rax,%rcx), %edx
andl %r15d, %edx
orl $0x80, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1a59(%rip), %rsi      # 0x40b2
movq %rax, %rdi
callq 0x2180
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x12, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
andl 0x18(%rax,%rcx), %r15d
orl $0x80, %r15d
movl %r15d, 0x18(%rax,%rcx)
leaq 0x1a22(%rip), %rsi      # 0x40af
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq 0x392c(%rip), %rdi      # 0x5fd0
leaq 0x19d1(%rip), %rsi      # 0x407c
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movb $0x0, (%r14)
orl $-0x1, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d4c
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]Ticket-Booking-Service/client/UserInterface.cpp
// Function: UserInterface::Run()
void UserInterface::Run() {

    int opt = -1;

    while(!mQuit) {

        while(mServers<1)
            Init();

        OptionMessage();
        std::cin >> opt;
        if(!std::cin.good()) {

            std::cout << "Unknow option! Please enter again." << std::endl;
            std::cin.clear();
            std::cin.ignore(INT_MAX, '\n');
            continue;
        }

        switch(opt) {
            case 1:
                BuyTickets();
                break;
            case 2:
                mQuit = true;
                break;
            default:
                std::cout << "Unknow option! Please enter again." << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2c(%rbp), %r14
orl $-0x1, (%r14)
movq 0x38d2(%rip), %r15      # 0x5fe0
movq 0x38bb(%rip), %r12      # 0x5fd0
leaq 0x19a5(%rip), %r13      # 0x40c1
cmpb $0x0, (%rbx)
je 0x272e
jmp 0x27c3
movq %rbx, %rdi
callq 0x27d2
cmpl $0x0, 0x4(%rbx)
jle 0x2726
callq 0x2a82
movq %r15, %rdi
movq %r14, %rsi
callq 0x2100
movq (%r15), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r15,%rax)
je 0x2789
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x2210
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %r15, %rdi
pushq $0xa
popq %rdx
callq 0x2110
jmp 0x271c
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
je 0x27a3
cmpl $0x1, %eax
jne 0x27ab
movq %rbx, %rdi
callq 0x2ad4
jmp 0x271c
movb $0x1, (%rbx)
jmp 0x271c
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
jmp 0x271c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]Ticket-Booking-Service/client/UserInterface.cpp
// Function: UserInterface::OptionMessage()
void UserInterface::OptionMessage() {

    std::cout << std::endl;
    std::cout << "1. Purchase Tickets" << std::endl;
    std::cout << "2. Quit" << std::endl;
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x3541(%rip), %rbx      # 0x5fd0
movq %rbx, %rdi
callq 0x20c0
leaq 0x16e3(%rip), %rsi      # 0x4181
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x16e0(%rip), %rsi      # 0x4195
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]Ticket-Booking-Service/client/main.cpp
// Function: main
int main(int argc, char* argv[]) {

    UserInterface* user = new UserInterface();

    user->Run();

    delete user;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $0x20
popq %rdi
callq 0x2190
movq %rax, %rbx
movq %rax, %rdi
callq 0x25dc
movq %rbx, %rdi
callq 0x26ee
movq %rbx, %rdi
callq 0x26e0
movq %rbx, %rdi
callq 0x2170
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
cmpl $0x1, %edi
jg 0x25de
movq (%rsi), %r14
movq 0x7ad7(%rip), %rdi      # 0x9fd0
leaq 0x3b04(%rip), %rsi      # 0x6004
callq 0x21c0
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3b3d(%rip), %rsi      # 0x6056
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3b5c(%rip), %rsi      # 0x6098
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3b4a(%rip), %rsi      # 0x609f
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x3b32(%rip), %rsi      # 0x60a1
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3b3e(%rip), %rsi      # 0x60c6
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3b54(%rip), %rsi      # 0x60f5
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3b58(%rip), %rsi      # 0x6112
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
pushq $0x1
popq %rax
jmp 0x2666
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2688
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x26b8
leaq 0x40(%rsp), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x98(%rsp), %rdi
callq 0x26fe
leaq 0x98(%rsp), %rdi
callq 0x2712
leaq 0x6(%rsp), %rbx
movw $0xff, (%rbx)
movq %rbx, %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rbx, 0x8(%rdx)
movq 0x8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x3078
leaq 0x58(%rsp), %rdi
callq 0x2712
leaq 0x20(%rsp), %rdi
callq 0x2728
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2673
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2728
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf3ba(%rip), %r15      # 0x14bb4
pushq $0x2
popq %r12
pushq $0x1
popq %r13
testq %rbx, %rbx
je 0x5831
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3200
cmpq $0x0, 0x10(%rbx)
je 0x5831
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x33a0
movq 0x10(%rbx), %rbx
jmp 0x5802
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, TypeQual*)
void print(FILE* fp, TypeQual* q)
{
    if (!q)
        return;
    if (q->qual == 'a') {
        fprintf(fp, "[");
        print(fp, q->args);
        fprintf(fp, "]");
    } else
        fprintf(fp, "%c", q->qual);
}

// Assembly:
testq %rsi, %rsi
je 0x5880
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rsi), %edi
cmpl $0x61, %edi
jne 0x5874
pushq $0x5b
popq %rdi
movq %rbx, %rsi
callq 0x3250
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x57df
pushq $0x5d
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3250
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf25f(%rip), %r15      # 0x14bb4
pushq $0x2
popq %r12
pushq $0x1
popq %r13
testq %rbx, %rbx
je 0x59a1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5881
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58b1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fc
cmpq $0x0, 0x30(%rbx)
je 0x59a1
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x33a0
movq 0x30(%rbx), %rbx
jmp 0x595d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: print(_IO_FILE*, Func*)
void print(FILE* fp, Func* f)
{
    if (!f)
        return;
    if (f->ret) {
        print_var(fp, f->ret);
        fprintf(fp, " = ");
    }
    if (f->thisv)
        fprintf(fp, "%s->%s.", f->thisv, f->classv);
    fprintf(fp, "%s(", f->funcv);
    print_args(fp, f->args);
    fprintf(fp, ");\n");
}

// Assembly:
testq %rsi, %rsi
je 0x5a44
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x59ec
movq %rbx, %rdi
callq 0x58fc
leaq 0xf031(%rip), %rdi      # 0x14a0f
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x33a0
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x5a0a
movq 0x38(%r14), %rcx
leaq 0x70e5(%rip), %rsi      # 0xcae5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32b0
movq 0x40(%r14), %rdx
leaq 0xef8f(%rip), %rsi      # 0x149a4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32b0
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x593a
leaq 0xfec9(%rip), %rdi      # 0x158fb
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x33a0
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](TypeQual*)
string id_string(TypeQual* q)
{
    if (!q)
        return "";
    if (q->qual == 'a')
        return "[" + id_string(q->args) + "]";
    else
        return (string() + q->qual);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5b16
movb (%rsi), %al
cmpb $0x61, %al
jne 0x5b2b
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x5a45
leaq 0x6fe5(%rip), %rsi      # 0xcacd
leaq -0x30(%rbp), %rdi
movq %r14, %rdx
callq 0x605a
leaq 0x6fd4(%rip), %rdx      # 0xcacf
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x6088
leaq -0x30(%rbp), %rdi
callq 0x33c8
leaq -0x50(%rbp), %rdi
jmp 0x5b4e
leaq 0xd73a(%rip), %rsi      # 0x13257
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x6014
jmp 0x5b53
leaq -0x20(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movsbl %al, %edx
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x60b1
leaq -0x30(%rbp), %rdi
callq 0x33c8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x33c8
jmp 0x5b79
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x5b7d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x33c8
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](Var*)
string id_string(Var* v)
{
    if (!v)
        return "";

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5bc7
movq %rsi, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl 0x9(%rsi), %eax
cmpl $0x67, %eax
je 0x5bdf
cmpl $0x63, %eax
jne 0x5bee
leaq 0x6f28(%rip), %rsi      # 0xcaed
jmp 0x5be6
leaq 0xd689(%rip), %rsi      # 0x13257
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x6014
jmp 0x5cab
leaq 0x6f0a(%rip), %rsi      # 0xcaf0
movq %rbx, %rdi
callq 0x3380
movb 0x8(%r14), %al
cmpb $0x6f, %al
leaq 0x6efc(%rip), %rcx      # 0xcaf7
leaq 0x6ef4(%rip), %rdx      # 0xcaf6
cmoveq %rcx, %rdx
cmpb $0x69, %al
leaq 0x6ee4(%rip), %rsi      # 0xcaf3
cmovneq %rdx, %rsi
movq %rbx, %rdi
callq 0x3380
movq 0x10(%r14), %rdi
callq 0x51b9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3380
movq 0x18(%r14), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5ab8
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x33c8
cmpl $0x13, 0x20(%r14)
jne 0x5c73
leaq 0xed15(%rip), %rsi      # 0x14974
movq %rbx, %rdi
callq 0x3380
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3380
cmpq $0x0, 0x30(%r14)
je 0x5cab
leaq 0xef33(%rip), %rsi      # 0x14bb4
movq %rbx, %rdi
callq 0x3380
movq 0x30(%r14), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5b8a
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x33c8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5cbb
jmp 0x5ccb
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x33c8
jmp 0x5cce
jmp 0x5ccb
movq %rax, %r14
movq %rbx, %rdi
callq 0x33c8
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: id_string[abi:cxx11](Func*)
string id_string(Func* f)
{
    if (!f)
        return "";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5dc7
movq %rsi, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x5d3e
leaq -0x30(%rbp), %rdi
callq 0x5b8a
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x33c8
leaq 0xecd9(%rip), %rsi      # 0x14a0f
movq %rbx, %rdi
callq 0x3380
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x5d79
movq %rbx, %rdi
callq 0x3380
leaq 0xeba3(%rip), %rsi      # 0x148f9
movq %rbx, %rdi
callq 0x3380
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3380
leaq 0x6d7a(%rip), %rsi      # 0xcaeb
movq %rbx, %rdi
callq 0x3380
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x3380
leaq 0xecba(%rip), %rsi      # 0x14a46
movq %rbx, %rdi
callq 0x3380
movq 0x48(%r14), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5b8a
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b0
leaq -0x30(%rbp), %rdi
callq 0x33c8
leaq 0x10953(%rip), %rsi     # 0x16710
movq %rbx, %rdi
callq 0x3380
jmp 0x5dda
leaq 0xd489(%rip), %rsi      # 0x13257
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x6014
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5dea
jmp 0x5dfa
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x33c8
jmp 0x5dfd
jmp 0x5dfa
movq %rax, %r14
movq %rbx, %rdi
callq 0x33c8
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Expr*)
void destroy(Expr* e)
{
    if (!e)
        return;
    destroy(e->next);
    delete[] e->value;
    delete e;
}

// Assembly:
testq %rdi, %rdi
je 0x5e43
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x5e0d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x5e32
callq 0x3260
pushq $0x18
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31a0
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy(Var*)
void destroy(Var* v)
{
    if (!v) 
        return;
    destroy(v->next);
    destroy(v->qual);
    delete[] v->basetype;
    delete[] v->name;
    delete v;
}

// Assembly:
testq %rdi, %rdi
je 0x5eba
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5e6d
movq 0x18(%rbx), %rdi
callq 0x5e44
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5e9b
callq 0x3260
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x5ea9
callq 0x3260
pushq $0x38
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31a0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x68
popq %rbx
testq %r14, %r14
je 0x5f31
movq 0x58(%r14), %r15
movq 0x60(%r14), %rdi
callq 0x5ebb
movq 0x50(%r14), %rdi
callq 0x5e6d
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x5ef4
callq 0x3260
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x5f02
callq 0x3260
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x5f10
callq 0x3260
movq 0x48(%r14), %rdi
callq 0x5e6d
movq %r14, %rdi
callq 0x33c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31a0
movq %r15, %r14
jmp 0x5ecb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-ast.cc
// Function: destroy_inherits()
void destroy_inherits()
{
    map<string,InheritsDecl*>::iterator i = class_decls.begin();
    for (; i != class_decls.end(); ++i) {
        destroy(i->second);
        i->second = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x1550d(%rip), %rbx     # 0x1b480
leaq 0x154f6(%rip), %r14     # 0x1b470
cmpq %r14, %rbx
je 0x5f9a
movq 0x40(%rbx), %rdi
callq 0x5f3c
andq $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x3120
movq %rax, %rbx
jmp 0x5f7a
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_dim_args(Var*, int&)
void label_dim_args(Var* v, int& icount)
{
    if (!v)
        return;
    if (v->qual)
        label_dim_args(v->qual->args, icount);
    label_dim_args(v->next, icount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x68fb
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x68f5
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x68b4
movq 0x30(%r14), %r14
jmp 0x68db
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: label_args(Var*, int&, int&)
void label_args(Var* v, int& icount, int& ocount)
{
    if (!v)
        return;
    if (v->iospec == 'i' || v->iospec == 'b')
        v->input_label = icount++;
    if (v->iospec == 'o' || v->iospec == 'b')
        v->output_label = ocount++;
    label_args(v->next, icount, ocount);
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x6161(%rip), %r12      # 0xcb24
xorl %r13d, %r13d
testq %r14, %r14
je 0x6aa8
movl 0x20(%r14), %eax
xorl %r15d, %r15d
decl %eax
cmpl $0x11, %eax
ja 0x6a02
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movl $0xc, 0x20(%r14)
jmp 0x6a02
movl $0xe, 0x20(%r14)
jmp 0x6a02
movl $0xd, 0x20(%r14)
movq 0x30(%r14), %r14
addl %r15d, %r13d
jmp 0x69c6
movq 0x145c6(%rip), %r15     # 0x1afd8
movq (%r15), %rdi
leaq 0x6150(%rip), %rsi      # 0xcb6c
movl %ebx, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r15), %rdi
movq 0x28(%r14), %rdx
leaq 0x6146(%rip), %rsi      # 0xcb79
jmp 0x6a5d
movq 0x1459c(%rip), %r15     # 0x1afd8
movq (%r15), %rdi
leaq 0x6126(%rip), %rsi      # 0xcb6c
movl %ebx, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r15), %rdi
movq 0x28(%r14), %rdx
leaq 0x613e(%rip), %rsi      # 0xcb9b
xorl %eax, %eax
callq 0x32b0
pushq $0x1
popq %r15
jmp 0x6a02
movq 0x14567(%rip), %rax     # 0x1afd8
movq (%rax), %rdi
xorl %r15d, %r15d
leaq 0x6144(%rip), %rsi      # 0xcbc2
movl %ebx, %edx
xorl %eax, %eax
callq 0x32b0
movq 0x1454a(%rip), %rax     # 0x1afd8
movq (%rax), %rdi
movq 0x28(%r14), %rdx
leaq 0x6135(%rip), %rsi      # 0xcbd1
xorl %eax, %eax
callq 0x32b0
jmp 0x6a02
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: fortranize_ret(Var*, int)
int fortranize_ret(Var* v, int line)
{
    if (!v)
        return 0;
    if (v->tinfo == VT_cscalar || v->tinfo == VT_zscalar) {
        fprintf(stderr, "Warning (%d): ", line);
        fprintf(stderr, "Danger returning complex from FORTRAN\n");
    } else if (v->tinfo != VT_scalar) {
        fprintf(stderr, "Error (%d): ", line);
        fprintf(stderr, "Can only return scalars from FORTRAN\n");
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6ad0
movl 0x20(%rdi), %eax
cmpl $0x6, %eax
jne 0x6ad7
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %edx
addl $-0x7, %eax
cmpl $0x1, %eax
ja 0x6b12
movq 0x144f0(%rip), %r14     # 0x1afd8
movq (%r14), %rdi
leaq 0x60d0(%rip), %rsi      # 0xcbc2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x32b0
movq (%r14), %rcx
leaq 0x60f3(%rip), %rdi      # 0xcbf8
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0x33a0
jmp 0x6ad0
movq 0x144bf(%rip), %rbx     # 0x1afd8
movq (%rbx), %rdi
leaq 0x6049(%rip), %rsi      # 0xcb6c
xorl %eax, %eax
callq 0x32b0
movq (%rbx), %rcx
leaq 0x60eb(%rip), %rdi      # 0xcc1f
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x33a0
pushq $0x1
popq %rbx
jmp 0x6ad0
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: fortranize_args(Func*, int)
int fortranize_args(Func* f, int line)
{
    if (!f->fort)
        return 0;
    return (fortranize_args(f->args, line) +
            fortranize_ret(f->ret, line));
}

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x6bb6
movzbl (%rax), %edx
cmpl $0x26, %edx
je 0x6bc1
movl %esi, %r10d
cmpl $0x72, %edx
je 0x6bcc
cmpl $0x61, %edx
je 0x6bbb
cmpl $0x2a, %edx
jne 0x6c54
movl %ecx, 0x20(%rbx)
jmp 0x6bc5
movl %edx, 0x20(%rbx)
jmp 0x6bc5
movl %r9d, 0x20(%rbx)
jmp 0x6bd6
movl %r8d, 0x20(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x10(%rbp), %ecx
movl %ecx, 0x20(%rbx)
testl %ecx, %ecx
je 0x6c1c
movq 0x8(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x6bc7
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x6bc7
cmpq $0x0, 0x10(%rcx)
je 0x6bc7
movq 0x143e0(%rip), %r14     # 0x1afd8
movq (%r14), %rdi
leaq 0x5f6a(%rip), %rsi      # 0xcb6c
movl %r10d, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r14), %rdi
movq 0x28(%rbx), %rdx
leaq 0x602b(%rip), %rsi      # 0xcc45
jmp 0x6c45
movq 0x143b5(%rip), %r14     # 0x1afd8
movq (%r14), %rdi
leaq 0x5f3f(%rip), %rsi      # 0xcb6c
movl %r10d, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r14), %rdi
movq 0x28(%rbx), %rdx
leaq 0x601d(%rip), %rsi      # 0xcc62
xorl %eax, %eax
callq 0x32b0
pushq $0x1
popq %rax
jmp 0x6bc7
leaq 0x62db(%rip), %rdi      # 0xcf36
leaq 0x6026(%rip), %rsi      # 0xcc88
leaq 0x6032(%rip), %rcx      # 0xcc9b
movl $0xb3, %edx
callq 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: typecheck_return(Var*, int)
int typecheck_return(Var* v, int line)
{
    if (!v)
        return 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6fc3
movl %esi, %r14d
movq %rdi, %r15
callq 0x6c73
movl %eax, %ebx
movl 0x20(%r15), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
ja 0x6f77
movq 0x18(%r15), %rcx
testq %rcx, %rcx
je 0x7002
cmpq $0x0, 0x8(%rcx)
je 0x7002
cmpl $0x9, %eax
je 0x6fca
cmpl $0x5, %eax
je 0x702f
cmpl $0x13, %eax
jne 0x7063
movq 0x14043(%rip), %r15     # 0x1afd8
movq (%r15), %rdi
leaq 0x5bcd(%rip), %rsi      # 0xcb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r15), %rcx
leaq 0x5e16(%rip), %rdi      # 0xcdc9
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x33a0
jmp 0x7061
xorl %ebx, %ebx
jmp 0x7063
cmpq $0x0, 0x18(%r15)
je 0x7063
movq 0x13ffc(%rip), %r12     # 0x1afd8
movq (%r12), %rdi
leaq 0x5b85(%rip), %rsi      # 0xcb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x5e12(%rip), %rsi      # 0xce12
jmp 0x705a
movq 0x13fcf(%rip), %r12     # 0x1afd8
movq (%r12), %rdi
leaq 0x5b58(%rip), %rsi      # 0xcb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x5d7c(%rip), %rsi      # 0xcda9
jmp 0x705a
movq 0x13fa2(%rip), %r12     # 0x1afd8
movq (%r12), %rdi
leaq 0x5b2b(%rip), %rsi      # 0xcb6c
movl %r14d, %edx
xorl %eax, %eax
callq 0x32b0
movq (%r12), %rdi
movq 0x28(%r15), %rdx
leaq 0x5d87(%rip), %rsi      # 0xcde1
xorl %eax, %eax
callq 0x32b0
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-typecheck.cc
// Function: typecheck(Func*, int)
int typecheck(Func* f, int line)
{
    label_args(f);
    return (typecheck_return(f->ret, line) + 
            typecheck_args(f->args, line) +
            fortranize_args(f, line));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x693d
movq 0x50(%r14), %rdi
movl %ebx, %esi
callq 0x6f36
movl %eax, %r15d
movq 0x48(%r14), %rdi
movl %ebx, %esi
callq 0x706e
movl %eax, %r12d
addl %r15d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x6b44
addl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_output_args(_IO_FILE*, Var*, int&)
void print_output_args(FILE* fp, Var* v, int& first)
{
    if (!v)
        return;
    if (v->iospec == 'o' || v->iospec == 'b') {
        if (!first)
            fprintf(fp, ", ");
        fprintf(fp, "%s", v->name);
        first = 0;
    }
    print_output_args(fp, v->next, first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %r13
pushq $0x1
popq %r12
testq %r14, %r14
je 0x72f8
movzbl 0x8(%r14), %eax
cmpl $0x6f, %eax
je 0x72c9
cmpl $0x62, %eax
jne 0x72f2
cmpl $0x0, (%rbx)
jne 0x72e3
leaq 0xd8df(%rip), %rdi      # 0x14bb4
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x33a0
movq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x3200
andl $0x0, (%rbx)
movq 0x30(%r14), %r14
jmp 0x72b5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_input_args(_IO_FILE*, Var*)
void print_input_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->tinfo == VT_const)
        fprintf(fp, ", 0");
    else if (v->iospec == 'i' || v->iospec == 'b')
        fprintf(fp, ", %s", v->name);
    print_input_args(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5c12(%rip), %r15      # 0xcf34
pushq $0x3
popq %r12
pushq $0x1
popq %r13
testq %rbx, %rbx
je 0x7371
cmpl $0x13, 0x20(%rbx)
jne 0x7348
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x33a0
jmp 0x736b
movzbl 0x8(%rbx), %eax
cmpl $0x69, %eax
je 0x7356
cmpl $0x62, %eax
jne 0x736b
movq 0x28(%rbx), %rdx
movq %r14, %rdi
leaq 0x5bd4(%rip), %rsi      # 0xcf38
xorl %eax, %eax
callq 0x32b0
movq 0x30(%rbx), %rbx
jmp 0x732a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_dimension_args(_IO_FILE*, Var*)
void print_dimension_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->qual)
        print_dimension_args(fp, v->qual->args);
    print_dimension_args(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x73eb
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x73e5
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x7380
movq 0x30(%rbx), %rbx
jmp 0x73cb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-mgen.cc
// Function: print_matlab_call(_IO_FILE*, Func*, char const*)
void print_matlab_call(FILE* fp, Func* f, const char* mexfunc)
{
    fprintf(fp, "mex_id_ = '%s';\n", id_string(f).c_str());
    if (f->ret || has_output_args(f->args)) {
        int first = 1;
        fprintf(fp, "[");
        print_output_args(fp, f->ret, first);
        print_output_args(fp, f->args, first);
        fprintf(fp, "] = ");
    }
    fprintf(fp, "%s(mex_id_", mexfunc);
    if (f->thisv)
        fprintf(fp, ", %s", f->thisv);
    print_input_args(fp, f->args);
    print_dimension_args(fp, f->ret);
    print_dimension_args(fp, f->args);
    fprintf(fp, ");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x5cde
movq (%r12), %rdx
leaq 0x5b1e(%rip), %rsi      # 0xcf3d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32b0
movq %r12, %rdi
callq 0x33c8
cmpq $0x0, 0x50(%r14)
jne 0x7445
movq 0x48(%r14), %rdi
callq 0x7270
testl %eax, %eax
je 0x748b
movl $0x1, (%r12)
pushq $0x5b
popq %rdi
movq %rbx, %rsi
callq 0x3250
movq 0x50(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7296
movq 0x48(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x7296
leaq 0xd591(%rip), %rdi      # 0x14a0e
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x33a0
leaq 0x5abc(%rip), %rsi      # 0xcf4e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x32b0
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x74b9
leaq 0x5a89(%rip), %rsi      # 0xcf38
movq %rbx, %rdi
xorl %eax, %eax
callq 0x32b0
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x7307
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x73be
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x73be
leaq 0xe417(%rip), %rdi      # 0x158fb
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x33a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: basetype_to_mxclassid(char const*)
char *basetype_to_mxclassid(const char* name)
{
  if( strcmp(name,"int32_t") == 0 ) return strdup("mxINT32_CLASS");
  if( strcmp(name,"int64_t") == 0 ) return strdup("mxINT64_CLASS");
  if( strcmp(name,"uint32_t") == 0 ) return strdup("mxUINT32_CLASS");
  if( strcmp(name,"uint64_t") == 0 ) return strdup("mxUINT64_CLASS");
  if( strcmp(name,"float") == 0 ) return strdup("mxSINGLE_CLASS");
  if( strcmp(name,"fcomplex") == 0 ) return strdup("mxSINGLE_CLASS");
  if( strcmp(name,"double") == 0 ) return strdup("mxDOUBLE_CLASS");
  if( strcmp(name,"dcomplex") == 0 ) return strdup("mxDOUBLE_CLASS");
  return strdup("mxVOID_CLASS");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x554a(%rip), %rsi      # 0xcaa6
callq 0x32a0
testl %eax, %eax
je 0x75fb
leaq 0x553f(%rip), %rsi      # 0xcaaf
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x7604
leaq 0x551e(%rip), %rsi      # 0xcaa5
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x760d
leaq 0x5514(%rip), %rsi      # 0xcaae
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x761f
leaq 0x54da(%rip), %rsi      # 0xca87
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x7616
leaq 0x4e76(%rip), %rsi      # 0xc436
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x7616
leaq 0x54ad(%rip), %rsi      # 0xca80
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x7628
leaq 0x4e47(%rip), %rsi      # 0xc42d
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
je 0x7628
leaq 0xb58e(%rip), %rdi      # 0x12b87
jmp 0x762f
leaq 0xb52d(%rip), %rdi      # 0x12b2f
jmp 0x762f
leaq 0xb532(%rip), %rdi      # 0x12b3d
jmp 0x762f
leaq 0xb537(%rip), %rdi      # 0x12b4b
jmp 0x762f
leaq 0xb54c(%rip), %rdi      # 0x12b69
jmp 0x762f
leaq 0xb534(%rip), %rdi      # 0x12b5a
jmp 0x762f
leaq 0xb549(%rip), %rdi      # 0x12b78
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: nullable_return(Func*)
bool nullable_return(Func* f)
{
    return (f->ret &&
            (f->ret->tinfo == VT_string ||
             is_array(f->ret->tinfo) ||
             f->ret->tinfo == VT_p_scalar ||
             f->ret->tinfo == VT_p_cscalar ||
             f->ret->tinfo == VT_p_zscalar));
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x6f, 0x8(%rdi)
jne 0x76b7
movl 0x4(%rdi), %edx
leaq 0xb4df(%rip), %rsi      # 0x12b94
jmp 0x76c0
movl (%rdi), %edx
leaq 0xb4db(%rip), %rsi      # 0x12b9b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
testq %rdi, %rdi
je 0x7722
movl 0x28(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movq 0x58(%rdi), %rdi
jmp 0x770f
popq %rbp
retq