LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_type(char*, Var*)
void mex_declare_type(char* typebuf, Var* v)
{
    if (is_obj(v->tinfo) || is_array(v->tinfo)){
        if(v->devicespec == 'g'){
            sprintf(typebuf, "%s*", basetype_to_cucomplex(v->basetype));
        }
        else{
            sprintf(typebuf, "%s*", v->basetype);
        }
    }
    else if (v->tinfo == VT_rarray){
        if(v->devicespec == 'g'){
            sprintf(typebuf, "const %s*", basetype_to_cucomplex(v->basetype));
        }
        else{
            sprintf(typebuf, "const %s*", v->basetype);
        }
    }
    else if (v->tinfo == VT_scalar ||
             v->tinfo == VT_cscalar ||
             v->tinfo == VT_zscalar ||
             v->tinfo == VT_r_scalar ||
             v->tinfo == VT_r_cscalar ||
             v->tinfo == VT_r_zscalar ||
             v->tinfo == VT_p_scalar ||
             v->tinfo == VT_p_cscalar ||
             v->tinfo == VT_p_zscalar)
        sprintf(typebuf, "%s", v->basetype);
    else if (v->tinfo == VT_string)
        sprintf(typebuf, "char*");
    else if (v->tinfo == VT_mx && v->iospec == 'i')
        sprintf(typebuf, "const mxArray*");
    else if (v->tinfo == VT_mx && v->iospec == 'o')
        sprintf(typebuf, "mxArray*");
    else {
        fprintf(stderr, "v->tinfo == %d; v->name = %s\n", v->tinfo, v->name);
        assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x20(%rsi), %eax
leal -0x1(%rax), %ecx
cmpl $0x11, %ecx
ja 0x923b
movq %rdi, %rbx
leaq 0x4e0c(%rip), %rdx      # 0xdf7c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%rsi), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3150
cmpb $0x67, 0x9(%rsi)
movq 0x10(%rsi), %rdx
jne 0x91ac
movq %rdx, %rdi
callq 0x7e44
leaq 0xb5d8(%rip), %rsi      # 0x1477c
movq %rbx, %rdi
movq %rax, %rdx
jmp 0x91b6
leaq 0xb5c9(%rip), %rsi      # 0x1477c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3080
cmpb $0x67, 0x9(%rsi)
movq 0x10(%rsi), %rdx
jne 0x920f
movq %rdx, %rdi
callq 0x7e44
leaq 0xb59a(%rip), %rsi      # 0x14776
jmp 0x91a4
cmpb $0x69, 0x8(%rsi)
jne 0x9218
movabsq $0x2a796172724178, %rax # imm = 0x2A796172724178
movq %rax, 0x7(%rbx)
movabsq $0x786d2074736e6f63, %rax # imm = 0x786D2074736E6F63
movq %rax, (%rbx)
jmp 0x9234
movw $0x2a, 0x4(%rbx)
movl $0x72616863, (%rbx)     # imm = 0x72616863
jmp 0x9234
leaq 0xb560(%rip), %rsi      # 0x14776
jmp 0x91b3
cmpl $0xa, %eax
jne 0x923b
cmpb $0x6f, 0x8(%rsi)
jne 0x923b
movabsq $0x2a7961727241786d, %rax # imm = 0x2A7961727241786D
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdi
movl %eax, %esi
callq 0x37b0
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_in_args(_IO_FILE*, Var*)
void mex_declare_in_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if ((v->iospec == 'i' || v->iospec == 'b') && v->tinfo != VT_const) {
        char typebuf[128];
        mex_declare_type(typebuf, v);
        if (is_array(v->tinfo) || is_obj(v->tinfo) || v->tinfo == VT_string) {
            fprintf(fp, "    %-10s  in%d_ =0; /* %-10s */\n",
                    typebuf, v->input_label, v->name);
            if(v->devicespec == 'g'){
                fprintf(fp, "    %-10s *mxGPUArray_in%d_ =0; /* %-10s */\n",
                       "mxGPUArray const", v->input_label, v->name);
            }
        } else {
            fprintf(fp, "    %-10s  in%d_;    /* %-10s */\n",
                    typebuf, v->input_label, v->name);
        }
    }
    mex_declare_in_args(fp, v->next);
}

// Assembly:
testq %rsi, %rsi
je 0x9310
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x8(%rsi), %eax
cmpl $0x69, %eax
je 0x9274
cmpl $0x62, %eax
jne 0x92f9
cmpl $0x13, 0x20(%r14)
je 0x92f9
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x9151
movl 0x20(%r14), %eax
cmpl $0xf, %eax
ja 0x92da
movl $0x8a1e, %ecx           # imm = 0x8A1E
btl %eax, %ecx
jae 0x92da
movl (%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb52c(%rip), %rsi      # 0x147d7
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
cmpb $0x67, 0x9(%r14)
jne 0x92f9
movl (%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb528(%rip), %rsi      # 0x147f9
leaq 0xb54e(%rip), %rdx      # 0x14826
jmp 0x92ef
movl (%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb54f(%rip), %rsi      # 0x14837
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x9245
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_out_args(_IO_FILE*, Var*)
void mex_declare_out_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->iospec == 'o' && v->tinfo != VT_mx) {
        char typebuf[128];
        mex_declare_type(typebuf, v);
        if (is_array(v->tinfo) || is_obj(v->tinfo) || v->tinfo == VT_string) {
            fprintf(fp, "    %-10s  out%d_=0; /* %-10s */\n",
                    typebuf, v->output_label, v->name);
            if(v->devicespec == 'g'){
                fprintf(fp, "    %-10s *mxGPUArray_out%d_ =0; /* %-10s */\n",
                       "mxGPUArray", v->output_label, v->name);
                fprintf(fp, "    %-10s gpu_outdims%d_[2] = {0,0}; /* %-10s dims*/\n",
                       "mwSize", v->output_label, v->name);
            }
        } else {
            fprintf(fp, "    %-10s  out%d_;   /* %-10s */\n",
                    typebuf, v->output_label, v->name);
        }
    }
    mex_declare_out_args(fp, v->next);
}

// Assembly:
testq %rsi, %rsi
je 0x93fb
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x6f, 0x8(%rsi)
jne 0x93e4
cmpl $0xa, 0x20(%r14)
je 0x93e4
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x9151
movl 0x20(%r14), %eax
cmpl $0xf, %eax
ja 0x93c4
movl $0x8a1e, %ecx           # imm = 0x8A1E
btl %eax, %ecx
jae 0x93c4
movl 0x4(%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb4e5(%rip), %rsi      # 0x14859
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
cmpb $0x67, 0x9(%r14)
jne 0x93e4
movl 0x4(%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb4e0(%rip), %rsi      # 0x1487b
leaq 0xb507(%rip), %rdx      # 0x148a9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movl 0x4(%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb4f9(%rip), %rsi      # 0x148b4
leaq 0xb528(%rip), %rdx      # 0x148ea
jmp 0x93da
movl 0x4(%r14), %ecx
movq 0x28(%r14), %r8
leaq 0xb51e(%rip), %rsi      # 0x148f1
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x9311
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_dim_args(_IO_FILE*, Expr*)
void mex_declare_dim_args(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, "    %-10s  dim%d_;   /* %-10s */\n",
            "mwSize", e->input_label, e->value);
    mex_declare_dim_args(fp, e->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb4ff(%rip), %r15      # 0x14913
leaq 0xb4cf(%rip), %r12      # 0x148ea
testq %rbx, %rbx
je 0x943c
movl (%rbx), %ecx
movq 0x8(%rbx), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x3270
movq 0x10(%rbx), %rbx
jmp 0x941b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_dim_args(_IO_FILE*, Var*)
void mex_declare_dim_args(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->qual)
        mex_declare_dim_args(fp, v->qual->args);
    mex_declare_dim_args(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x9472
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x946c
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x93fc
movq 0x30(%rbx), %rbx
jmp 0x9452
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_declare_args(_IO_FILE*, Func*)
void mex_declare_args(FILE* fp, Func* f)
{
    if (f->thisv) {
        char typebuf[128];
        strcpy(typebuf, f->classv);
        strcat(typebuf, "*");
        fprintf(fp, "    %-10s  in%d_ =0; /* %-10s */\n",
                typebuf, 0, f->thisv);
    }
    mex_declare_in_args(fp, f->args);
    if (!nullable_return(f))
        mex_declare_return(fp, f->ret);
    mex_declare_out_args(fp, f->args);
    mex_declare_dim_args(fp, f->ret);
    mex_declare_dim_args(fp, f->args);
    if (f->ret || f->args || f->thisv)
        fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %r15
testq %r15, %r15
je 0x94e0
movq 0x38(%r14), %rsi
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
callq 0x3150
movq %r12, %rdi
callq 0x30d0
movw $0x2a, -0xa0(%rbp,%rax)
leaq 0xb309(%rip), %rsi      # 0x147d7
movq %rbx, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x3270
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x9245
movq 0x50(%r14), %rsi
testq %rsi, %rsi
je 0x950f
movl 0x20(%rsi), %eax
cmpl $0x9, %eax
ja 0x9507
movl $0x21c, %ecx            # imm = 0x21C
btl %eax, %ecx
jb 0x9517
addl $-0xc, %eax
cmpl $0x3, %eax
jb 0x9517
movq %rbx, %rdi
callq 0x9311
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x9311
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x9445
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x9445
cmpq $0x0, 0x50(%r14)
jne 0x9550
cmpq $0x0, 0x48(%r14)
jne 0x9550
cmpq $0x0, 0x30(%r14)
je 0x955d
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3230
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_unpack_dims(_IO_FILE*, Expr*)
int mex_unpack_dims(FILE* fp, Expr* e)
{
    if (!e)
        return 0;
    fprintf(fp,
            "    dim%d_ = (mwSize) mxWrapGetScalar(prhs[%d], &mw_err_txt_);\n",
            e->input_label, e->input_label);
    return mex_unpack_dims(fp, e->next)+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb3b0(%rip), %r12      # 0x14935
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x95a7
movl (%rbx), %ecx
movq %r14, %rdi
movq %r12, %rsi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3270
movq 0x10(%rbx), %rbx
incl %r15d
jmp 0x9588
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_unpack_dims(_IO_FILE*, Var*)
int mex_unpack_dims(FILE* fp, Var* v)
{
    if (!v)
        return 0;
    if (v->qual)
        return
            mex_unpack_dims(fp, v->qual->args) +
            mex_unpack_dims(fp, v->next);
    return mex_unpack_dims(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x95ef
movq 0x18(%rbx), %rax
testq %rax, %rax
jne 0x95da
movq 0x30(%rbx), %rbx
jmp 0x95c6
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x956d
movq 0x30(%rbx), %rbx
addl %eax, %r14d
jmp 0x95c6
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_check_dims(_IO_FILE*, Var*)
void mex_check_dims(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->iospec != 'o' && is_array(v->tinfo) && v->qual && v->qual->args && v->devicespec != 'g') {
        Expr* a = v->qual->args;
        if (a->next) {
            fprintf(fp,
                    "    if (mxGetM(prhs[%d]) != dim%d_ ||\n"
                    "        mxGetN(prhs[%d]) != dim%d_) {\n"
                    "        mw_err_txt_ = \"Bad argument size: %s\";\n"
                    "        goto mw_err_label;\n"
                    "    }\n\n",
                    v->input_label, a->input_label,
                    v->input_label, a->next->input_label,
                    v->name);
        } else {
            fprintf(fp,
                    "    if (mxGetM(prhs[%d])*mxGetN(prhs[%d]) != dim%d_) {\n"
                    "        mw_err_txt_ = \"Bad argument size: %s\";"
                    "        goto mw_err_label;\n"
                    "    }\n\n",
                    v->input_label, v->input_label, a->input_label,
                    v->name);
        }
    }
    mex_check_dims(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb3ba(%rip), %r15      # 0x14a13
leaq 0xb315(%rip), %r12      # 0x14975
testq %rbx, %rbx
je 0x96d5
cmpb $0x6f, 0x8(%rbx)
je 0x96cf
movl 0x20(%rbx), %eax
addl $-0x2, %eax
cmpl $0x2, %eax
ja 0x96cf
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x96cf
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x96cf
cmpb $0x67, 0x9(%rbx)
je 0x96cf
movq 0x10(%rax), %rcx
movl (%rbx), %edx
movl (%rax), %r8d
testq %rcx, %rcx
je 0x96bc
movl (%rcx), %r9d
movq 0x28(%rbx), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
movl %r8d, %ecx
movl %edx, %r8d
xorl %eax, %eax
callq 0x3270
jmp 0x96cf
movq 0x28(%rbx), %r9
movq %r14, %rdi
movq %r15, %rsi
movl %edx, %ecx
xorl %eax, %eax
callq 0x3270
movq 0x30(%rbx), %rbx
jmp 0x9660
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_alloc_size1(_IO_FILE*, Expr*)
void mex_alloc_size1(FILE* fp, Expr* e)
{
    if (!e)
        return;
    fprintf(fp, "dim%d_", e->input_label);
    if (e->next) {
        fprintf(fp, "*");
        mex_alloc_size1(fp, e->next);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc69d(%rip), %r15      # 0x15dab
testq %rbx, %rbx
je 0x973c
movl (%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
cmpq $0x0, 0x10(%rbx)
je 0x973c
movl $0x2a, %edi
movq %r14, %rsi
callq 0x3230
movq 0x10(%rbx), %rbx
jmp 0x970e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_unpack_input_string(_IO_FILE*, Var*)
void mex_unpack_input_string(FILE* fp, Var* v)
{
    if (!(v->qual && v->qual->args))
        fprintf(fp,
                "    in%d_ = mxWrapGetString(prhs[%d], &mw_err_txt_);\n"
                "    if (mw_err_txt_)\n"
                "        goto mw_err_label;\n",
                v->input_label, v->input_label);
    else {
        fprintf(fp, "    in%d_ = (char*) mxMalloc(",
                v->input_label);
        mex_alloc_size(fp, v->qual->args);
        fprintf(fp, "*sizeof(char));\n");
        fprintf(fp, "    if (mxGetString(prhs[%d], in%d_, ",
                v->input_label, v->input_label);
        mex_alloc_size(fp, v->qual->args);
        fprintf(fp, ") != 0) {\n"
                "        mw_err_txt_ = \"Invalid string argument\";\n"
                "        goto mw_err_label;\n"
                "    }\n");
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x998d
cmpq $0x0, 0x8(%rax)
je 0x998d
movl (%r14), %edx
leaq 0xb810(%rip), %rsi      # 0x15129
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq 0x18(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x9747
leaq 0xb80d(%rip), %rdi      # 0x15147
movl $0x10, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movl (%r14), %ecx
leaq 0xb802(%rip), %rsi      # 0x15158
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3270
movq 0x18(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x9747
leaq 0xb805(%rip), %rdi      # 0x1517e
movl $0x5c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
jmp 0x99a3
movl (%r14), %ecx
leaq 0xb72c(%rip), %rsi      # 0x150c3
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3270
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_check_inputs(_IO_FILE*, Var*)
void mex_check_inputs(FILE* fp, Var* v)
{
    if (!v)
        return;
    if (v->iospec != 'o' && (v->tinfo == VT_obj || v->tinfo == VT_r_obj))
        fprintf(fp,
                "    if (!in%d_) {\n"
                "        mw_err_txt_ = \"Argument %s cannot be null\";\n"
                "        goto mw_err_label;\n"
                "    }\n",
                v->input_label, v->name);
    mex_check_inputs(fp, v->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xbb75(%rip), %r15      # 0x156d8
testq %rbx, %rbx
je 0x9b94
cmpb $0x6f, 0x8(%rbx)
je 0x9b8e
movl 0x20(%rbx), %eax
cmpl $0xf, %eax
je 0x9b7b
cmpl $0x1, %eax
jne 0x9b8e
movl (%rbx), %edx
movq 0x28(%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x30(%rbx), %rbx
jmp 0x9b63
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_make_call(_IO_FILE*, Var*, int)
void mex_make_call(FILE* fp, Var* v, int first)
{
    if (!v)
        return;
    if (!first)
        fprintf(fp, ", ");

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

// Assembly:
testq %rsi, %rsi
je 0x9f69
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jne 0x9e9c
leaq 0xbd4a(%rip), %rdi      # 0x15bd4
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movl 0x20(%r14), %eax
leal -0xa(%rax), %ecx
cmpl $0x9, %ecx
ja 0x9ed3
leaq 0x415d(%rip), %rdx      # 0xe00c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq -0xa0(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe0
leaq 0xba40(%rip), %rsi      # 0x15911
jmp 0x9ef1
cmpl $0x1, %eax
jne 0x9f31
leaq -0xa0(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe0
leaq 0xba14(%rip), %rsi      # 0x15905
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3270
jmp 0x9f4e
cmpb $0x6f, 0x8(%r14)
jne 0x9f1e
movl 0x4(%r14), %edx
leaq 0xb9f7(%rip), %rsi      # 0x15909
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
jmp 0x9f4e
leal -0xc(%rax), %ecx
cmpl $0x3, %ecx
jb 0x9eb8
cmpl $0x13, %eax
jne 0x9f31
movq 0x28(%r14), %rdi
jmp 0x9f46
leaq -0xa0(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x31d0
movq 0x30(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9e60
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_make_call(_IO_FILE*, Func*)
void mex_make_call(FILE* fp, Func* f)
{
    if (f->thisv)
        fprintf(fp, "in0_->");
    if (strcmp(f->funcv, "new") == 0)
        fprintf(fp, "new %s(", f->classv);
    else {
        if (f->fort)
            fprintf(fp, "MWF77_");
        fprintf(fp, "%s(", f->funcv);
    }
    mex_make_call(fp, f->args, 1);
    fprintf(fp, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0x9f9b
leaq 0xb98c(%rip), %rdi      # 0x15915
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq 0x40(%r14), %rdi
leaq 0x34bd(%rip), %rsi      # 0xd463
callq 0x3260
testl %eax, %eax
je 0x9fdc
leaq 0x40(%r14), %r12
leaq 0xba0a(%rip), %r15      # 0x159c4
cmpb $0x1, 0x24(%r14)
jne 0x9fe7
leaq 0xb954(%rip), %rdi      # 0x1591c
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
jmp 0x9fe7
leaq 0x38(%r14), %r12
leaq 0xb9d9(%rip), %r15      # 0x159c0
movq (%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x48(%r14), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x9e60
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: mex_marshal_results(_IO_FILE*, Var*, bool)
void mex_marshal_results(FILE* fp, Var* v, bool return_flag)
{
    if (!v)
        return;
    if (v->iospec != 'i')
        mex_marshal_result(fp, v, return_flag);
    mex_marshal_results(fp, v->next, return_flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl %dl, %r15d
testq %rbx, %rbx
je 0xa98b
cmpb $0x69, 0x8(%rbx)
je 0xa985
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0xa76b
movq 0x30(%rbx), %rbx
jmp 0xa96c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_c_comment(_IO_FILE*, Func*)
void print_c_comment(FILE* fp, Func* f)
{
    fprintf(fp, "/* ---- %s: %d ----\n * ", f->fname.c_str(), f->line);
    print(fp, f);
    for (Func* fsame = f->same_next; fsame; fsame = fsame->next)
        fprintf(fp, " * Also at %s: %d\n", fsame->fname.c_str(), fsame->line);
    fprintf(fp, " */\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdx
movl 0x20(%rsi), %ecx
leaq 0xb5f3(%rip), %rsi      # 0x161c0
xorl %eax, %eax
callq 0x3270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62c7
movq 0x60(%r14), %r15
testq %r15, %r15
je 0xac0c
leaq 0xb5e9(%rip), %r14      # 0x161d8
movq (%r15), %rdx
movl 0x20(%r15), %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x58(%r15), %r15
testq %r15, %r15
jne 0xabef
leaq 0x970f(%rip), %rdi      # 0x14322
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_stub(_IO_FILE*, Func*)
void print_mex_stub(FILE* fp, Func* f)
{
    print_c_comment(fp, f);
    fprintf(fp,
            "static const char* stubids%d_ = \"%s\";\n\n"
            "void mexStub%d(int nlhs, mxArray* plhs[],\n"
            "              int nrhs, const mxArray* prhs[])\n"
            "{\n"
            "    const char* mw_err_txt_ = 0;\n",
            f->id, id_string(f).c_str(), f->id);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xabb0
movl 0x28(%r14), %r15d
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x67e0
movq (%r12), %rcx
movl 0x28(%r14), %r8d
leaq 0xb580(%rip), %rsi      # 0x161eb
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x3270
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xac91
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9481
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95fd
testq %rbx, %rbx
je 0xacb8
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x963d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b1a
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x9b4c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9dfb
movl 0x28(%r14), %edx
leaq 0xabe9(%rip), %rsi      # 0x158ce
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa01e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa996
leaq 0xb583(%rip), %rdi      # 0x1628f
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab61
leaq 0xb56f(%rip), %rdi      # 0x1629f
movl $0x3b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: make_profile_output(_IO_FILE*, Func*, char const*)
void make_profile_output(FILE* fp, Func* f, const char* printfunc)
{
    fprintf(fp,
            "        if (!mexprofrecord_)\n"
            "            %s\"Profiler inactive\\n\");\n",
            printfunc);
    for (; f; f = f->next) {
        fprintf(fp, "        %s\"%%d calls to %s:%d",
                printfunc, f->fname.c_str(), f->line);
        for (Func* fsame = f->same_next; fsame; fsame = fsame->next)
            fprintf(fp, " (%s:%d)", fsame->fname.c_str(), fsame->line);
        fprintf(fp, "\\n\", mexprofrecord_[%d]);\n", f->id);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb56e(%rip), %rsi      # 0x162db
xorl %eax, %eax
callq 0x3270
testq %r14, %r14
je 0xaddd
leaq 0xb5bd(%rip), %r12      # 0x1633d
movq (%r14), %rcx
movl 0x20(%r14), %r8d
movq %r15, %rdi
leaq 0xb58e(%rip), %rsi      # 0x1631f
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
movq 0x60(%r14), %r13
testq %r13, %r13
je 0xadbf
movq (%r13), %rdx
movl 0x20(%r13), %ecx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
movq 0x58(%r13), %r13
jmp 0xad9f
movl 0x28(%r14), %edx
movq %r15, %rdi
leaq 0xb579(%rip), %rsi      # 0x16346
xorl %eax, %eax
callq 0x3270
movq 0x58(%r14), %r14
testq %r14, %r14
jne 0xad80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_else_cases(_IO_FILE*, Func*)
void print_mex_else_cases(FILE* fp, Func* f)
{
    for (Func* fcall = f; fcall; fcall = fcall->next)
        fprintf(fp,
                "    else if (strcmp(id, stubids%d_) == 0)\n"
                "        mexStub%d(nlhs,plhs, nrhs-1,prhs+1);\n",
                fcall->id, fcall->id);

    int maxid = max_routine_id(f);

    fprintf(fp,
            "    else if (strcmp(id, \"*profile on*\") == 0) {\n"
            "        if (!mexprofrecord_) {\n"
            "            mexprofrecord_ = (int*) malloc(%d * sizeof(int));\n"
            "            mexLock();\n"
            "        }\n"
            "        memset(mexprofrecord_, 0, %d * sizeof(int));\n"
            "    } else if (strcmp(id, \"*profile off*\") == 0) {\n"
            "        if (mexprofrecord_) {\n"
            "            free(mexprofrecord_);\n"
            "            mexUnlock();\n"
            "        }\n"
            "        mexprofrecord_ = NULL;\n"
            "    } else if (strcmp(id, \"*profile report*\") == 0) {\n",
            maxid+1, maxid+1);

    make_profile_output(fp, f, "mexPrintf(");

    fprintf(fp,
            "    } else if (strcmp(id, \"*profile log*\") == 0) {\n"
            "        FILE* logfp;\n"
            "        if (nrhs != 2 || mxGetString(prhs[1], id, sizeof(id)) != 0)\n"
            "            mexErrMsgTxt(\"Must have two string arguments\");\n"
            "        logfp = fopen(id, \"w+\");\n"
            "        if (!logfp)\n"
            "            mexErrMsgTxt(\"Cannot open log for output\");\n");

    make_profile_output(fp, f, "fprintf(logfp, ");

    fprintf(fp, "        fclose(logfp);\n");

    fprintf(fp,
            "    } else\n"
            "        mexErrMsgTxt(\"Unknown identifier\");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xae6f
leaq 0xb52d(%rip), %r15      # 0x16361
movq %r14, %r12
movl 0x28(%r12), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3270
movq 0x58(%r12), %r12
testq %r12, %r12
jne 0xae37
xorl %ecx, %ecx
movq %r14, %rax
movl 0x28(%rax), %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movq 0x58(%rax), %rax
testq %rax, %rax
jne 0xae5a
incl %ecx
jmp 0xae74
movl $0x1, %ecx
leaq 0xb53e(%rip), %rsi      # 0x163b9
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x3270
leaq 0xb6fa(%rip), %rdx      # 0x16588
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad4f
leaq 0xb6f3(%rip), %rdi      # 0x16593
movl $0x135, %esi            # imm = 0x135
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0xb810(%rip), %rdx      # 0x166c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad4f
leaq 0xb80e(%rip), %rdi      # 0x166d9
movl $0x17, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0xb80d(%rip), %rdi      # 0x166f1
movl $0x37, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_init(_IO_FILE*)
void print_mex_init(FILE* fp)
{

    fprintf(fp, "%s", mwrap_banner);
    fprintf(fp, "%s", mex_header);

    fprintf(fp, "\n");
    if (mw_use_gpu)
        mex_use_gpu(fp);
    if (mw_use_c99_complex)
        mex_c99_complex(fp);
    else if (mw_use_cpp_complex)
      {
        mex_cpp_complex(fp);
	if (mw_use_gpu)
	  mex_gpucpp_complex(fp);
      }

    //    fprintf(fp, "\n");
    //    fprintf(fp, "%s", mwrap_compat_type_support);
    //    fprintf(fp, "\n");
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x112e1(%rip), %rdi     # 0x1c1f0
movq %rbx, %rsi
callq 0x31d0
movq 0x112ca(%rip), %rdi     # 0x1c1e8
movq %rbx, %rsi
callq 0x31d0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3230
leaq 0x112f6(%rip), %r14     # 0x1c230
cmpb $0x1, (%r14)
jne 0xaf59
leaq 0x8c7a(%rip), %rdi      # 0x13bc1
movl $0x1d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
leaq 0x112d3(%rip), %rax     # 0x1c233
cmpb $0x1, (%rax)
jne 0xaf82
leaq 0x8dea(%rip), %rdi      # 0x13d56
movl $0x14d, %esi            # imm = 0x14D
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3370
leaq 0x112a9(%rip), %rax     # 0x1c232
cmpb $0x1, (%rax)
jne 0xafbb
leaq 0x8c4a(%rip), %rdi      # 0x13bdf
movl $0x15d, %esi            # imm = 0x15D
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
cmpb $0x1, (%r14)
jne 0xafbb
leaq 0x8d89(%rip), %rdi      # 0x13d3d
movl $0x18, %esi
jmp 0xaf71
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_file(_IO_FILE*, Func*)
void print_mex_file(FILE* fp, Func* f)
{

    mex_define_copiers(fp);
    mex_casting_getters(fp);

    if (has_fortran(f)) {
        mex_define_fnames(fp, f);
        mex_fortran_decls(fp, f);
    }

    print_mex_stubs(fp, f);
    fprintf(fp, "%s", mexBase);
    fprintf(fp, "\n");
    if (mw_use_gpu)
        fprintf(fp, "    mxInitGPU();\n");
    fprintf(fp, "\n");
    fprintf(fp, "%s", mexBaseIf);
    print_mex_else_cases(fp, f);
    fprintf(fp, "}\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x836d
movq %rbx, %rdi
callq 0x8fff
testq %r14, %r14
setne %al
je 0xb001
cmpb $0x0, 0x24(%r14)
jne 0xb001
movq %r14, %rcx
movq 0x58(%rcx), %rcx
testq %rcx, %rcx
setne %al
je 0xb001
cmpb $0x0, 0x24(%rcx)
je 0xafef
testb %al, %al
je 0xb01b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8bc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8d8b
testq %r14, %r14
je 0xb037
movq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xac2f
movq 0x58(%r15), %r15
testq %r15, %r15
jne 0xb023
movq 0x111ba(%rip), %rdi     # 0x1c1f8
movq %rbx, %rsi
callq 0x31d0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3230
leaq 0x111d6(%rip), %rax     # 0x1c230
cmpb $0x1, (%rax)
jne 0xb078
leaq 0xb99f(%rip), %rdi      # 0x16a05
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3230
movq 0x11174(%rip), %rdi     # 0x1c200
movq %rbx, %rsi
callq 0x31d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xae17
leaq 0xb231(%rip), %rdi      # 0x162d7
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/statgen[P]statgen/lib/tclap-1.2.0/examples/test5.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for A OR B we got : " << _orTest<< endl
		 << "for string C we got : " << _testc << endl
		 << "for string D we got : " << _testd << endl
		 << "for E or F or G we got: " << _orTest2 << endl;

}

// Assembly:
pushq %rbx
callq 0x36cf
movq 0xfa57(%rip), %rbx      # 0x12fd0
leaq 0xaaa2(%rip), %rsi      # 0xe022
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31d0
movq 0xfc3c(%rip), %rsi      # 0x131d0
movq 0xfc3d(%rip), %rdx      # 0x131d8
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq 0xaa60(%rip), %rsi      # 0xe037
movl $0x16, %edx
movq %rax, %rdi
callq 0x31d0
movq 0xfc25(%rip), %rsi      # 0x13210
movq 0xfc26(%rip), %rdx      # 0x13218
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq 0xaa20(%rip), %rsi      # 0xe04e
movl $0x16, %edx
movq %rax, %rdi
callq 0x31d0
movzbl 0xfbee(%rip), %esi      # 0x13230
movq %rbx, %rdi
callq 0x3280
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq 0xa9e7(%rip), %rsi      # 0xe065
movl $0x18, %edx
movq %rax, %rdi
callq 0x31d0
movq 0xfb5e(%rip), %rsi      # 0x131f0
movq 0xfb5f(%rip), %rdx      # 0x131f8
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: print_lookup(std::array<unsigned char, 8ul>)
void print_lookup(perm_t perm) {
    int result[SEG_LENGTH][SEG_LENGTH];
    memset(result, -1, sizeof result);
    for (int i = 1; i <= SEG_LENGTH; i++) {
        for (int j = 0; j < i; j++) {
            result[j][i-1] = std::min_element(perm.begin() + j, perm.begin() + i) - perm.begin();
        }
    }
    putchar('{');
    for (int i = 0; i < SEG_LENGTH; i++)
        for (int j = 0; j < SEG_LENGTH; j++)
            printf("%d,", result[i][j]);
    printf("},\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
leaq 0x10(%rsp), %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1090
movl $0x1, %eax
xorl %ecx, %ecx
leaq (%rsp,%rax), %rdx
addq $0x8, %rdx
leaq -0x1(%rax), %rsi
movq %rcx, %rdi
xorl %r8d, %r8d
leaq (%rsp,%r8), %r15
addq $0x8, %r15
leaq (%rsp,%r8), %r9
addq $0x9, %r9
cmpq %rdx, %r9
je 0x1849
movq %rdi, %r10
movb (%r9), %bpl
movq %r9, %r11
cmpb (%r15), %bpl
jb 0x183c
movq %r15, %r11
incq %r9
movq %r11, %r15
decq %r10
jne 0x182e
jmp 0x184c
movq %r15, %r11
subl %r14d, %r11d
movq %r8, %r9
shlq $0x5, %r9
addq %rsp, %r9
addq $0x10, %r9
movl %r11d, (%r9,%rsi,4)
incq %r8
decq %rdi
cmpq %rax, %r8
jne 0x1816
incq %rax
incq %rcx
cmpq $0x9, %rax
jne 0x1804
movl $0x7b, %edi
callq 0x1100
leaq 0x17a0(%rip), %r14      # 0x3029
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incq %r12
cmpq $0x8, %r12
jne 0x188f
incq %r15
addq $0x20, %rbx
cmpq $0x8, %r15
jne 0x188c
leaq 0x1971(%rip), %rdi      # 0x322b
callq 0x1140
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: print_lookup_pref(std::array<unsigned char, 8ul>)
void print_lookup_pref(perm_t perm) {
    putchar('{');
    for (int i = 1; i <= SEG_LENGTH; i++) {
        int value = std::min_element(perm.begin(), perm.begin() + i) - perm.begin(); 
        printf("%d,", value);
    }
    printf("},\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x9(%rsp), %r14
movq %rdi, -0x1(%r14)
movl $0x7b, %edi
callq 0x1100
movl $0x1, %r15d
leaq 0x8(%rsp), %r12
leaq 0x1728(%rip), %rbx      # 0x3029
xorl %r13d, %r13d
movq %r12, %rsi
cmpq $0x1, %r15
je 0x192f
movq %r13, %rax
movq %r14, %rcx
movq %r12, %rdx
movb (%rcx), %dil
movq %rcx, %rsi
cmpb (%rdx), %dil
jb 0x1924
movq %rdx, %rsi
incq %rcx
movq %rsi, %rdx
decq %rax
jne 0x1916
subl %r12d, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r15
incq %r13
cmpq $0x9, %r15
jne 0x1904
leaq 0x18dc(%rip), %rdi      # 0x322b
callq 0x1140
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: print_lookup_suf(std::array<unsigned char, 8ul>)
void print_lookup_suf(perm_t perm) {
    putchar('{');
    for (int i = 0; i < SEG_LENGTH; i++) {
        int value = std::min_element(perm.begin() + i, perm.end()) - perm.begin(); 
        printf("%d,", value);
    }
    printf("},\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movl $0x7b, %edi
callq 0x1100
leaq 0x16a5(%rip), %rbx      # 0x3029
xorl %r15d, %r15d
leaq (%rsp,%r15), %rsi
addq $0x8, %rsi
leaq 0x1(%r15), %rax
cmpq $0x8, %rax
je 0x19ae
movb 0x8(%rsp,%rax), %cl
cmpb (%rsi), %cl
jae 0x19a9
leaq (%rsp,%rax), %rsi
addq $0x8, %rsi
incq %rax
jmp 0x1993
subl %r14d, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r15
cmpq $0x8, %r15
jne 0x1987
leaq 0x1860(%rip), %rdi      # 0x322b
callq 0x1140
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: work()
void work() {
    perm_t perm; std::iota(perm.begin(), perm.end(), 0);
    do {
        preorder_t preorder = perm_to_preorder(perm);
        int id = tree_id.emplace(preorder, tree_id.size()).first->second;
        if (id == trees.size()) {
            trees.emplace_back(preorder);
            tree_sample.emplace(preorder, perm);
        }
        instances.emplace_back(perm, instances.size(), id);
    } while (std::next_permutation(perm.begin(), perm.end()));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movabsq $0x706050403020100, %rax # imm = 0x706050403020100
leaq 0x28(%rsp), %rbx
movq %rax, -0x8(%rbx)
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x20(%rsp), %r13
leaq 0x4757(%rip), %rbp      # 0x6168
leaq 0xc(%rsp), %r14
movq 0x20(%rsp), %rdi
callq 0x156c
movq %rax, 0x18(%rsp)
movq 0x46fc(%rip), %rax      # 0x6128
movq %rax, 0x10(%rsp)
leaq 0x46c8(%rip), %rdi      # 0x6100
movq %r15, %rsi
movq %r12, %rdx
callq 0x2648
movslq 0x28(%rax), %rax
movl %eax, 0xc(%rsp)
movq 0x469e(%rip), %rsi      # 0x60f0
movq %rsi, %rcx
subq 0x468c(%rip), %rcx      # 0x60e8
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x1aa1
cmpq 0x468c(%rip), %rsi      # 0x60f8
je 0x1a80
movq 0x18(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x4672(%rip)      # 0x60f0
jmp 0x1a8f
leaq 0x4661(%rip), %rdi      # 0x60e8
movq %r15, %rdx
callq 0x27ba
leaq 0x469a(%rip), %rdi      # 0x6130
movq %r15, %rsi
movq %r13, %rdx
callq 0x28f6
movq 0x46c8(%rip), %rax      # 0x6170
subq 0x46b9(%rip), %rax      # 0x6168
sarq $0x4, %rax
movq %rax, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1b78
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2bf0
testb %al, %al
jne 0x1a16
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::decision_tree_node(std::vector<instance, std::allocator<instance>> const&, int)
decision_tree_node(const std::vector<instance>& instances, int dep) {
        id = next_node_id++;
        tree_id = should_stop(instances);
        if (tree_id >= 0) {
            crit = -1;
        } else {
            crit = select_criterion(instances);
            std::vector<instance> subtree_inst[2];
            for (auto& inst : instances) 
                subtree_inst[inst.bs[crit]].push_back(inst);
            for (int i = 0; i < 2; i++)
                subtree[i] = new decision_tree_node(subtree_inst[i], dep + 1);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl 0x458c(%rip), %eax      # 0x6160
leal 0x1(%rax), %ecx
movl %ecx, 0x4583(%rip)      # 0x6160
movl %eax, (%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movl 0xc(%rcx), %eax
cmpq %rdx, %rcx
je 0x1bfe
cmpl %eax, 0xc(%rcx)
jne 0x1bf9
addq $0x10, %rcx
jmp 0x1be9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8(%r14)
testl %eax, %eax
js 0x1c13
movl $0xffffffff, 0x4(%r14)  # imm = 0xFFFFFFFF
jmp 0x1cd5
movq %r15, %rdi
callq 0x1f2c
movl %eax, 0x4(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, %r12
je 0x1c7c
movq (%r12), %rax
movl 0x4(%r14), %ecx
xorl %edx, %edx
btq %rcx, %rax
setb %dl
leaq (%rdx,%rdx,2), %rax
leaq (%rsp,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1c6e
movups (%r12), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rdi)
jmp 0x1c76
movq %r12, %rdx
callq 0x1fd6
addq $0x10, %r12
jmp 0x1c37
addq $0x10, %r14
incl %ebx
movq %rsp, %r15
xorl %r13d, %r13d
movl $0x20, %edi
callq 0x10d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x1bb2
movq %r12, (%r14,%r13,8)
incq %r13
addq $0x18, %r15
cmpq $0x1, %r13
je 0x1c88
movl $0x30, %ebx
movq -0x18(%rsp,%rbx), %rdi
testq %rdi, %rdi
je 0x1ccf
movq -0x8(%rsp,%rbx), %rsi
subq %rdi, %rsi
callq 0x10e0
addq $-0x18, %rbx
jne 0x1cb8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1ce5
movq %rax, %rbx
jmp 0x1cfa
movq %rax, %rbx
movl $0x20, %esi
movq %r12, %rdi
callq 0x10e0
movl $0x30, %r14d
movq -0x18(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x1d17
movq -0x8(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x10e0
addq $-0x18, %r14
jne 0x1d00
movq %rbx, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::serialize()
void serialize() {
        if (crit < 0) {
            printf("    {-1, %d, -1, -1},\n", tree_id);
        } else {
            printf("    {%d, -1, %d, %d},\n", 
                crit, subtree[0]->id, subtree[1]->id);
        }
        if (subtree[0]) subtree[0]->serialize();
        if (subtree[1]) subtree[1]->serialize();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1498(%rip), %r14      # 0x31cd
leaq 0x14a8(%rip), %r15      # 0x31e4
movl 0x4(%rbx), %esi
testl %esi, %esi
js 0x1d5b
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rax), %edx
movl (%rcx), %ecx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
jmp 0x1d68
movl 0x8(%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1d76
callq 0x1d26
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d3c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::select_criterion(std::vector<instance, std::allocator<instance>> const&)
static int select_criterion(const std::vector<instance>& instances) {
        // balance rule
        int cnt[SEG_LENGTH * SEG_LENGTH] = {0};
        for (int i = 0; i < SEG_LENGTH * SEG_LENGTH; i++) {
            for (auto& inst : instances) if (inst.bs[i]) cnt[i]++;
            cnt[i] = std::min(cnt[i], (int)instances.size() - cnt[i]);
        }
        return std::max_element(std::begin(cnt), std::end(cnt)) - cnt;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %r15
movq %rsp, %rbx
xorl %r14d, %r14d
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq (%r15), %rax
movq 0x8(%r15), %rdx
movq %rdx, %rsi
subq %rax, %rsi
shrq $0x4, %rsi
cmpq %rdx, %rax
je 0x1f86
movl $0x1, %edi
movl %r14d, %ecx
shlq %cl, %rdi
movq %rax, %rcx
testq %rdi, (%rcx)
je 0x1f7d
incl (%rsp,%r14,4)
addq $0x10, %rcx
cmpq %rdx, %rcx
jne 0x1f74
movl (%rsp,%r14,4), %ecx
movl %esi, %edi
subl %ecx, %edi
cmpl %ecx, %edi
cmovgel %ecx, %edi
movl %edi, (%rsp,%r14,4)
incq %r14
cmpq $0x40, %r14
jne 0x1f61
movl $0x4, %eax
movl (%rbx), %ecx
cmpl (%rsp,%rax), %ecx
jge 0x1fb0
leaq (%rsp,%rax), %rbx
addq $0x4, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x1fa5
movq %rsp, %rax
subq %rax, %rbx
shrq $0x2, %rbx
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wx-csy[P]librmq/prep.cpp
// Function: instance::instance(std::array<unsigned char, 8ul>, int, int)
instance(perm_t perm, int perm_id, int tree_id) :
            perm_id(perm_id), tree_id(tree_id) {
        std::memset(&bs, 0, sizeof bs);
        for (int i = 0; i < SEG_LENGTH; i++)
            for (int j = 0; j < i; j++)
                bs[j * SEG_LENGTH + i] = (perm[j] < perm[i]);
    }

// Assembly:
movq %rsi, -0x8(%rsp)
movq $0x0, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
xorl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x2be6
movb -0x8(%rsp,%rax), %dl
movq %rax, %rsi
xorl %r8d, %r8d
movq %rcx, %r9
btrq %rsi, %r9
btsq %rsi, %rcx
cmpb %dl, -0x8(%rsp,%r8)
cmovaeq %r9, %rcx
incq %r8
addq $0x8, %rsi
cmpq %r8, %rax
jne 0x2bc3
movq %rcx, (%rdi)
incq %rax
cmpq $0x8, %rax
jne 0x2bb4
retq