LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::def(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Model::def(std::string model_type){
    /*
        max -> 1
        min -> -1
    */

    if(!model_type.compare("max")){
        type = model_type;
        // for 'max problem' the coefs have the opposite sign on the tableau
        type_id = -1; 
    }else if(!model_type.compare("min")){
        type = model_type;
        type_id = 1;
    }else{
        std::cout << "Invalid constraint type" << std::endl; 
        exit(0);
    }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x76d6(%rip), %rsi      # 0xc0b9
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x4a06
leaq 0x769a(%rip), %rsi      # 0xc090
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
jne 0x4a1d
pushq $0x1
jmp 0x4a08
pushq $-0x1
popq %rbp
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2110
movl %ebp, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0xd5b4(%rip), %rdi      # 0x11fd8
leaq 0x78b5(%rip), %rsi      # 0xc2e0
callq 0x2190
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::cstr_add(Model::cstr)
void Model::cstr_add(Model::cstr constraint){

    if(constraint.coef_get().size() != var_qnt){
        std::cout << "Invalid constraint's variables" << std::endl;
        exit(0);
    }
        
    cstr_vec.push_back(constraint);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3fd8
movq 0x8(%r15), %r12
subq (%r15), %r12
sarq $0x3, %r12
movslq (%r14), %r13
movq %r15, %rdi
callq 0x415a
cmpq %r13, %r12
jne 0x4b32
addq $0x58, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x923e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xd49f(%rip), %rdi      # 0x11fd8
leaq 0x77c8(%rip), %rsi      # 0xc308
callq 0x2190
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::analyse_add(Model::cstr)
void Model::analyse_add(Model::cstr cstr_new){

    if(cstr_new.coef_get().size() != var_qnt){
        std::cout << "Invalid constraint added to analysis" << std::endl;
        exit(0);
    }

    cstr_vec_new.push_back(cstr_new); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3fd8
movq 0x8(%r15), %r12
subq (%r15), %r12
sarq $0x3, %r12
movslq (%r14), %r13
movq %r15, %rdi
callq 0x415a
cmpq %r13, %r12
jne 0x4bc2
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x923e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xd40f(%rip), %rdi      # 0x11fd8
leaq 0x7757(%rip), %rsi      # 0xc327
callq 0x2190
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::vec_multiply_scalar(std::vector<double, std::allocator<double>>&, double)
void Model::vec_multiply_scalar(std::vector<double> & vec, double scalar){
    for(int i = 0; i < vec.size(); i++){
        if(vec[i] <= DBL_EPSILON && vec[i] >= -DBL_EPSILON) //eq to 0
            continue;

        vec[i] *= scalar;
    }
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
movapd 0x7684(%rip), %xmm1     # 0xc280
movsd 0x76ac(%rip), %xmm2     # 0xc2b0
cmpq %rdx, %rcx
je 0x4c2a
movsd (%rax,%rdx,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
ucomisd %xmm4, %xmm2
jae 0x4c25
mulsd %xmm0, %xmm3
movsd %xmm3, (%rax,%rdx,8)
incq %rdx
jmp 0x4c04
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::inverse_matrix_store()
void Model::inverse_matrix_store(){
    inverse_matrix = std::vector<std::vector<double>> (I_index.size(), std::vector<double> (I_index.size()));

    for(int i = 0; i < I_index.size(); i++){
        int col = I_index[i];
        for(int j = 1; j < tableau.size(); j++){
            inverse_matrix[j-1][i] = tableau[j][col]; 
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x198(%rdi), %rbx
subq 0x190(%rdi), %rbx
sarq $0x2, %rbx
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x92b8
leaq 0x28(%rsp), %rdi
leaq 0xe(%rsp), %rcx
movq %rbx, %rsi
movq %r15, %rdx
callq 0x930a
leaq 0x1a8(%r14), %rbx
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa48c
movq %r15, %rdi
callq 0x91c4
leaq 0x10(%rsp), %rdi
callq 0x415a
movq 0x198(%r14), %rcx
movq 0x190(%r14), %rsi
subq %rsi, %rcx
sarq $0x2, %rcx
movq 0x88(%r14), %rdi
movq 0x90(%r14), %rax
subq %rdi, %rax
pushq $0x18
popq %r8
cqto
idivq %r8
xorl %edx, %edx
pushq $0x1
popq %r8
cmpq %rdx, %rcx
jbe 0x50dc
movslq (%rsi,%rdx,4), %r9
movq (%rbx), %r10
xorl %r11d, %r11d
movq %r8, %r14
cmpq %r14, %rax
jbe 0x50d7
movq 0x18(%rdi,%r11), %r15
movsd (%r15,%r9,8), %xmm0
movq (%r10,%r11), %r15
movsd %xmm0, (%r15,%rdx,8)
incq %r14
addq $0x18, %r11
jmp 0x50b4
incq %rdx
jmp 0x50a2
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x415a
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::basic_coef_get()
void Model::basic_coef_get(){
    std::vector<double> coef (tableau.size() - 1);
    for(int col = 0; col < tableau[0].size(); col++){
        if(tableau[0][col] == 0){
            for(int row = 1; row < tableau.size(); row++){
                if(tableau[row][col] == 1)
                    coef[row-1] = -1 * type_id * original_coef[col];
            }
        }
    }

    basic_coef.clear();
    basic_coef = coef;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rax
subq 0x88(%rdi), %rax
pushq $0x18
popq %r14
cqto
idivq %r14
leaq -0x1(%rax), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x92b8
movq 0x88(%rbx), %rcx
movq 0x90(%rbx), %rax
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
subq %rcx, %rax
cqto
idivq %r14
addq $0x18, %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
pushq $0x1
popq %r8
movsd 0x6ee4(%rip), %xmm1     # 0xc050
cmpq %rdi, %rdx
je 0x51d1
movsd (%rsi,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x51cc
jp 0x51cc
xorl %r9d, %r9d
subl 0x28(%rbx), %r9d
cvtsi2sd %r9d, %xmm2
movq 0x1c0(%rbx), %r9
movq 0x8(%rsp), %r10
movq %rcx, %r11
movq %r8, %r14
cmpq %r14, %rax
jbe 0x51cc
movq (%r11), %r15
movsd (%r15,%rdx,8), %xmm3
ucomisd %xmm1, %xmm3
jne 0x51c3
jp 0x51c3
movsd (%r9,%rdx,8), %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, -0x8(%r10,%r14,8)
incq %r14
addq $0x18, %r11
jmp 0x519c
incq %rdx
jmp 0x516c
leaq 0x1d8(%rbx), %rdi
movq 0x1d8(%rbx), %rax
cmpq %rax, 0x1e0(%rbx)
je 0x51ef
movq %rax, 0x1e0(%rbx)
leaq 0x8(%rsp), %rsi
callq 0x9360
leaq 0x8(%rsp), %rdi
callq 0x415a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x415a
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::solution_primal_get(std::vector<double, std::allocator<double>>&)
void Model::solution_primal_get(std::vector<double> & solution_primal){
    if(!solution_primal.empty())
        solution_primal.clear();

    const int s_col = tableau[0].size() - 1;
    
    for(int i = 0; i < var_qnt; i++){
        if(tableau[0][i] == 0){
            for(int j = 1; j < tableau.size(); j++){
                if(tableau[j][i] == 1)
                    solution_primal.push_back(tableau[j][s_col]);
            }
        }else
            solution_primal.push_back(0);
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r8
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x5240
movq %rax, 0x8(%r8)
movq 0x88(%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shlq $0x1d, %rcx
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
addq %rcx, %r12
sarq $0x1d, %r12
xorl %r13d, %r13d
movq %r8, %rbp
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x52fe
movq 0x88(%r14), %rcx
movq (%rcx), %rax
movsd (%rax,%r13,8), %xmm0
ucomisd 0x703b(%rip), %xmm0     # 0xc2c8
jne 0x52e3
jp 0x52e3
pushq $0x18
popq %r15
pushq $0x1
popq %rbx
movq 0x90(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rbx, %rax
jbe 0x52f6
movq (%rcx,%r15), %rsi
movsd (%rsi,%r13,8), %xmm0
ucomisd 0x6d8f(%rip), %xmm0     # 0xc050
jne 0x52da
jp 0x52da
addq %r12, %rsi
movq %r8, %rdi
callq 0x9296
movq %rbp, %r8
movq 0x88(%r14), %rcx
incq %rbx
addq $0x18, %r15
jmp 0x5298
andq $0x0, (%rsp)
movq %r8, %rdi
movq %rsp, %rsi
callq 0xa03e
movq %rbp, %r8
incq %r13
jmp 0x5269
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::solution_dual_get(std::vector<double, std::allocator<double>>&)
void Model::solution_dual_get(std::vector<double> & solution_dual){
    if(!solution_dual.empty())
        solution_dual.clear();
        
    inverse_matrix_store();
    basic_coef_get();
    
    for(int i = 0; i < inverse_matrix.size(); i++){
        double sum = 0;
        for(int j = 0; j < inverse_matrix.size(); j++){
            sum += basic_coef[j] * inverse_matrix[j][i]; 
        }

        if(sum < DBL_EPSILON && sum > -DBL_EPSILON)
            sum = 0;

        solution_dual.push_back(sum);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x532e
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x4ffc
movq %r14, %rdi
callq 0x50fc
xorl %r12d, %r12d
pushq $0x18
popq %r13
leaq 0x8(%rsp), %r15
movq 0x1a8(%r14), %rcx
movq 0x1b0(%r14), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x53ca
andq $0x0, 0x8(%rsp)
movq 0x1d8(%r14), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rax
je 0x539e
movsd (%rdx,%rsi,8), %xmm1
movq (%rcx), %rdi
mulsd (%rdi,%r12,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
incq %rsi
addq $0x18, %rcx
jmp 0x5378
andpd 0x6eda(%rip), %xmm0     # 0xc280
movsd 0x6f02(%rip), %xmm1     # 0xc2b0
ucomisd %xmm0, %xmm1
jbe 0x53ba
andq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9296
incq %r12
jmp 0x534a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::b_opt_store()
void Model::b_opt_store(){
    if(!b_opt.empty())
        b_opt.clear();
            
    const int s_col = tableau[0].size() - 1;
    for(int j = 1; j < tableau.size(); j++)
        b_opt.push_back(tableau[j][s_col]);
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %rax
cmpq 0x120(%rdi), %rax
je 0x53fd
movq %rax, 0x120(%rbx)
movq 0x88(%rbx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
leaq 0x118(%rbx), %r14
shlq $0x1d, %rax
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
addq %rax, %r15
sarq $0x1d, %r15
pushq $0x1
popq %r12
pushq $0x18
popq %r13
movq %r13, %rbp
movq 0x90(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x5465
movq (%rcx,%rbp), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x9296
incq %r12
movq 0x88(%rbx), %rcx
addq $0x18, %rbp
jmp 0x5432
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::b_range_calc(std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>&)
void Model::b_range_calc(std::vector<std::pair<double, double>> & b_range){
    b_opt_store();    
    
    if(!b_range.empty())
        b_range.clear();

    //std::cout << "inve size " << inverse_matrix.size() << std::endl;
    for(int col = 0; col < inverse_matrix[0].size(); col++){
        double upper_bound = INFINITE; 
        double lower_bound = -INFINITE;


        //if(col == 6)
            //vec_print_dbl(b_opt);
        for(int row = 0; row < inverse_matrix.size(); row++){
            double coef =  inverse_matrix[row][col];
            double coef_inv = 1.0f / coef;
            double value = -1.0 * b_opt[row];

            value = value * coef_inv;

            if(coef_inv < 0 && value < upper_bound){
                upper_bound = value; 

            }else if(value > lower_bound){
                lower_bound = value;
            }

        }

        std::pair<double, double> range;
        range.first = lower_bound;
        range.second = upper_bound;

        b_range.push_back(range);

        //std::cout << "cstr n" << col << "  de " << lower_bound << " a " << upper_bound << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x53d8
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x5499
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
pushq $0x18
popq %r13
movq %rsp, %r15
movsd 0x6ba5(%rip), %xmm4     # 0xc050
movapd 0x6ddd(%rip), %xmm5     # 0xc290
xorpd %xmm6, %xmm6
movq 0x1a8(%r14), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x5574
movq 0x118(%r14), %rsi
movq 0x1b0(%r14), %rax
subq %rcx, %rax
cqto
idivq %r13
xorl %edx, %edx
movsd 0x6dde(%rip), %xmm0     # 0xc2d0
movsd 0x6dc6(%rip), %xmm1     # 0xc2c0
cmpq %rdx, %rax
je 0x5542
movq (%rcx), %rdi
movapd %xmm4, %xmm3
divsd (%rdi,%r12,8), %xmm3
movsd (%rsi,%rdx,8), %xmm2
xorpd %xmm5, %xmm2
mulsd %xmm3, %xmm2
ucomisd %xmm3, %xmm6
jbe 0x552b
ucomisd %xmm2, %xmm0
jbe 0x552b
movapd %xmm2, %xmm0
jmp 0x5531
ucomisd %xmm1, %xmm2
ja 0x5535
movapd %xmm1, %xmm2
incq %rdx
addq $0x18, %rcx
movapd %xmm2, %xmm1
jmp 0x54fa
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9422
xorpd %xmm6, %xmm6
movapd 0x6d2c(%rip), %xmm5     # 0xc290
movsd 0x6ae4(%rip), %xmm4     # 0xc050
incq %r12
jmp 0x54b7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::analyse()
void Model::analyse(){
    if(!solved){
        std::cout << "The Model wasnt already solved to be analysed\n";
        exit(0);
    }
    
    tableau = solution_tableau;

    // right hand
    b_range_calc(b_range);
    c_range_calc(c_range);

    analysed = true;

    output_generate();
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x40(%rdi)
je 0x5796
movq %rdi, %rbx
leaq 0xa0(%rdi), %rsi
addq $0x88, %rdi
callq 0x9440
leaq 0x130(%rbx), %rsi
movq %rbx, %rdi
callq 0x5474
leaq 0x160(%rbx), %rsi
movq %rbx, %rdi
callq 0x5582
movb $0x1, 0x41(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x57b0
movq 0xc83b(%rip), %rdi      # 0x11fd8
leaq 0x6ba8(%rip), %rsi      # 0xc34c
callq 0x2190
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::analyse_reopt()
void Model::analyse_reopt(){
    if(!solved){
        std::cout << "The Model wasnt already solved to be analysed\n";
        exit(0);
    }else if(cstr_vec_new.empty()){
        std::cout << "No constraints added for re-optimal analysis" << std::endl;
        exit(0);
    }else
        tableau = solution_tableau;

    for(int i = 0; i < cstr_vec_new.size(); i++){
        tableau_resize(cstr_vec_new[i]);
    }

    //tableau_print();
    solver(tableau);
    
    obj_value_mod = obj_value_get();
    solution_primal_get(solution_primal_mod);
    solution_dual_get(solution_dual_mod);

    // right hand
    b_range_calc(b_range_mod);
    c_range_calc(c_range_mod);
    analysed_mod = true;
    output_mod_generate();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x40(%rdi)
je 0x7197
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
je 0x71ac
leaq 0xa0(%rbx), %rsi
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq 0x9440
xorl %r12d, %r12d
pushq $0x48
popq %r13
movq %rsp, %r15
xorl %ebp, %ebp
movq 0x70(%rbx), %rsi
movq 0x78(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r13
cmpq %rbp, %rax
jbe 0x712d
addq %r12, %rsi
movq %r15, %rdi
callq 0x3e98
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6d5a
movq %r15, %rdi
callq 0x3edc
incq %rbp
addq $0x48, %r12
jmp 0x70f1
movq %r14, %rdi
callq *0x48(%rbx)
movq %rbx, %rdi
callq 0x71e2
movsd %xmm0, 0x38(%rbx)
leaq 0xd0(%rbx), %rsi
movq %rbx, %rdi
callq 0x5222
leaq 0x100(%rbx), %rsi
movq %rbx, %rdi
callq 0x530e
leaq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x5474
leaq 0x178(%rbx), %rsi
movq %rbx, %rdi
callq 0x5582
movb $0x1, 0x42(%rbx)
movq %rbx, %rdi
callq 0x7216
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xae3a(%rip), %rdi      # 0x11fd8
leaq 0x51a7(%rip), %rsi      # 0xc34c
callq 0x2190
jmp 0x71c7
movq 0xae25(%rip), %rdi      # 0x11fd8
leaq 0x51c1(%rip), %rsi      # 0xc37b
callq 0x2190
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3edc
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::obj_func::var_name_get[abi:cxx11](int)
std::string Model::obj_func::var_name_get(int n){
    if(n > var_name.size() - 1){
        std::cout << "Missing some var_name" << std::endl;
        exit(0);
    }
    return var_name[n];
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movslq %edx, %rcx
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rax
subq %rsi, %rax
sarq $0x5, %rax
decq %rax
cmpq %rcx, %rax
jb 0x8c04
movq %rdi, %rbx
shlq $0x5, %rcx
addq %rcx, %rsi
callq 0x2200
movq %rbx, %rax
popq %rbx
retq
movq 0x93cd(%rip), %rdi      # 0x11fd8
leaq 0x396c(%rip), %rsi      # 0xc57e
callq 0x2190
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::solve()
void Model::solve(){
    tableau_generate();
    solver(tableau);
    tableau_print();
    solution_tableau = tableau;
    
    obj_value = obj_value_get();
    solution_primal_get(solution_primal);
    solution_dual_get(solution_dual);
    solved = true;

    output_generate();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4cc2
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq *0x48(%rbx)
movq %rbx, %rdi
callq 0x8c94
leaq 0xa0(%rbx), %rdi
movq %r14, %rsi
callq 0x9440
movq %rbx, %rdi
callq 0x71e2
movsd %xmm0, 0x30(%rbx)
leaq 0xb8(%rbx), %rsi
movq %rbx, %rdi
callq 0x5222
leaq 0xe8(%rbx), %rsi
movq %rbx, %rdi
callq 0x530e
movb $0x1, 0x40(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57b0
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::tableau_print()
void Model::tableau_print(){
    for(int i = 0; i < tableau.size(); i++){
        for(int j = 0; j < tableau[i].size(); j++){
            std::cout << tableau[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x932c(%rip), %r14      # 0x11fd8
leaq 0x3747(%rip), %r15      # 0xc3fa
movq 0x88(%rbx), %rcx
movq 0x90(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r12, %rax
jbe 0x8d1f
imulq $0x18, %r12, %rbp
xorl %r13d, %r13d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x8d12
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
callq 0x2280
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
incq %r13
movq 0x88(%rbx), %rcx
jmp 0x8cd8
movq %r14, %rdi
callq 0x20f0
incq %r12
jmp 0x8cb3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::obj_func::coef_add(double)
void Model::obj_func::coef_add(double var_coef){

    if(coef.size() + 1 > var_qnt){
        std::cout << "Invalid OF size" << std::endl;
        exit(0);
    }

    coef.push_back(var_coef);
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
sarq $0x3, %rax
incq %rax
movslq (%rdi), %rcx
cmpq %rcx, %rax
ja 0x902b
addq $0x20, %rdi
movq %rsp, %rsi
callq 0x9296
popq %rax
retq
movq 0x8fa6(%rip), %rdi      # 0x11fd8
leaq 0x32bf(%rip), %rsi      # 0xc2f8
callq 0x2190
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/model.cpp
// Function: Model::cstr::type_def(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Model::cstr::type_def(cstr_t tp){
    
    /*
       0 -> eq
       1 -> leq
       -1 -> geq
     */

    if(!tp.compare("eq")){
        type = tp;
        type_id = 0;
    }else if(!tp.compare("leq")){
        type = tp;
        type_id = 1;
    }else if(!tp.compare("geq")){
        type = tp;
        type_id = -1;
    }else
        std::cout << "Invalid constraint type" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ffe(%rip), %rsi      # 0xc0a1
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x90f7
leaq 0x2fe6(%rip), %rsi      # 0xc09c
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x9108
leaq 0x2fd7(%rip), %rsi      # 0xc0a0
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x911c
movq 0x8efc(%rip), %rdi      # 0x11fd8
leaq 0x31fd(%rip), %rsi      # 0xc2e0
callq 0x2190
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
andl $0x0, 0x20(%rbx)
jmp 0x912b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
movl $0x1, 0x20(%rbx)
jmp 0x912b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
orl $-0x1, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: tableau_print(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
void tableau_print(const Tableau & tableau){
    for(int i = 0; i < tableau.size(); i++){
        for(int j = 0; j < tableau[i].size(); j++){
            std::cout << tableau[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x7190(%rip), %r14      # 0x11fd8
leaq 0x15ab(%rip), %r15      # 0xc3fa
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r12, %rax
jbe 0xaeb0
imulq $0x18, %r12, %rbp
xorl %r13d, %r13d
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0xaea3
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
callq 0x2280
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
incq %r13
movq (%rbx), %rcx
jmp 0xae6d
movq %r14, %rdi
callq 0x20f0
incq %r12
jmp 0xae4f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: pivot_column_clean(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int, int)
void pivot_column_clean(Tableau & tableau, int row, int column){
    double d = 1.0f / tableau[row][column];
    
    // divide row by the coeficient of x_i
    vec_multiply_scalar(tableau[row], d);

    for(int i = 0; i < tableau.size(); i++){
        double x_coef = tableau[i][column];
        //std::cout << "line  " << i << " coef  "<< x_coef << std::endl;
        if(x_coef == 0 || i == row) //eq to 0
            continue;

        vec_add_vec(tableau[i], tableau[row], -x_coef); 
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq (%rdi), %rdi
imulq $0x18, %r14, %rcx
movslq %edx, %r15
movq (%rdi,%rcx), %rax
movq %rcx, (%rsp)
addq %rcx, %rdi
movsd 0x10eb(%rip), %xmm0     # 0xc050
divsd (%rax,%r15,8), %xmm0
callq 0xaebf
movl %r14d, %r12d
xorl %r13d, %r13d
pushq $0x18
popq %rbp
xorl %r14d, %r14d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %rbp
cmpq %r14, %rax
jbe 0xafc9
cmpq %r14, %r12
je 0xafc0
movq (%rsi,%r13), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd 0x1321(%rip), %xmm0     # 0xc2c8
jne 0xafab
jnp 0xafc0
leaq (%rsi,%r13), %rdi
addq (%rsp), %rsi
xorpd 0x12d5(%rip), %xmm0     # 0xc290
callq 0xaf06
incq %r14
addq $0x18, %r13
jmp 0xaf7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: simplex_pivot_column_identify(std::vector<double, std::allocator<double>>)
int simplex_pivot_column_identify(std::vector<double> obj_func){
    double min = 0.0f;
    int min_i = -1;
    for(int i = 0; i < obj_func.size() - 1; i++){
        if(obj_func[i] < min){
            min = obj_func[i];
            min_i = i;
        }
    }

    return min_i;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
decq %rdx
pushq $-0x1
popq %rax
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xb010
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm1, %xmm0
cmoval %esi, %eax
minsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
jmp 0xaff2
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: simplex_solve(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void simplex_solve(Tableau & tableau){
    int count = 0;
    while(true){

        //tableau_print(tableau);
        //std::cout << std::endl;
        int column = simplex_pivot_column_identify(tableau[0]);

        if(column == -1)
            break;
        int row = simplex_pivot_row_identify(tableau, column);

        pivot_column_clean(tableau, row, column);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3fd8
movq %r14, %rdi
callq 0xafd8
movl %eax, %ebp
movq %r14, %rdi
callq 0x415a
cmpl $-0x1, %ebp
je 0xb0dc
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb011
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0xaf37
jmp 0xb0a2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: dual_simplex_pivot_row_identify(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int)
int dual_simplex_pivot_row_identify(Tableau & tableau, int pivot_row){
    double lim;
    double lim_min  = 9999999;
    int col_i;
    int f_row = 0;     
    for(int col = 0; col < tableau[0].size() - 1; col++){
        double co_ij = tableau[pivot_row][col];
        if(co_ij >= 0) //geq then 0
            continue;
        
        lim = tableau[f_row][col] / co_ij;
        lim = std::abs(lim);

        if(lim < lim_min ){
            lim_min = lim;
            col_i = col;
        }

    }

    return col_i;
}

// Assembly:
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
decq %rdx
movslq %esi, %rsi
imulq $0x18, %rsi, %rsi
addq %rax, %rsi
movsd 0x1526(%rip), %xmm0     # 0xc6a0
xorl %edi, %edi
xorpd %xmm1, %xmm1
movapd 0x10f8(%rip), %xmm2     # 0xc280
cmpq %rdi, %rdx
je 0xb1bd
movq (%rsi), %r8
movsd (%r8,%rdi,8), %xmm3
ucomisd %xmm1, %xmm3
jae 0xb1b8
movsd (%rcx,%rdi,8), %xmm4
divsd %xmm3, %xmm4
andpd %xmm2, %xmm4
ucomisd %xmm4, %xmm0
cmoval %edi, %eax
minsd %xmm0, %xmm4
movapd %xmm4, %xmm0
incq %rdi
jmp 0xb188
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: dual_simplex_solve(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void dual_simplex_solve(Tableau & tableau){
    while(true){
        //tableau_print(tableau);
        int row = dual_simplex_pivot_row_identify(tableau);

        //std::cout << "linha " << row << std::endl;
        if(row == -1)
            break;

        int column = dual_simplex_pivot_row_identify(tableau, row);
        //std::cout << "coluna " << column << std::endl;

        pivot_column_clean(tableau, row, column);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %rdi
callq 0xb0e5
cmpl $-0x1, %eax
je 0xb1eb
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0xb154
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xaf37
jmp 0xb1c4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mororo18[P]simplex-method/src/simplex.cpp
// Function: algo_def(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
void algo_def(Tableau & tableau){
    bool simplex = false;
    for(int col = 0; col < tableau[0].size() - 1; col++){
        if(tableau[0][col] < 0)
            simplex = true;
    }

    if(simplex)
        simplex_solve(tableau);
    else
        dual_simplex_solve(tableau);
}

// Assembly:
movq (%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
decq %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rdx, %rcx
je 0xb224
ucomisd (%rax,%rdx,8), %xmm0
seta %r8b
orb %r8b, %sil
incq %rdx
jmp 0xb20e
testb $0x1, %sil
jne 0xb092
jmp 0xb1be
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/str_x.c
// Function: do_mem
static double
do_mem(char const *name, MEMF fn, MEMREF const*rv, int nr, int count, char *pat, char **exp)
{
    int     i, r, patlen = strlen(pat);
    double  start = tick();
    char    *cp, *sp;

    //do_mem never called before do_str
    for (r = 0; r < nr; ++r) {
        cp = fn((char*)(intptr_t)rv[r].ptr, rv[r].len, pat, patlen);
        if (exp[r] != cp) {
            fprintf(stderr, "%s(pat='%s' [%d] exp=%"FSIZE"d act=%"FSIZE"d) failed\n\t[%"FSIZE"d] %s\n", name, pat, r,
                    exp[r] ? exp[r] - rv[r].ptr : -1, cp ? cp - rv[r].ptr : -1, 
                    rv[r].len, sp = acstr(rv[r].ptr, rv[r].len));
            free(sp);
            return 0;
        }
    }

    for (i = 0; i < count; ++i)
        for (r = 0; r < nr; ++r)
            if (exp[r] != fn((char*)(intptr_t)rv[r].ptr, rv[r].len, pat, patlen))
                return 0;

    return tick() - start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %r9, 0x18(%rsp)
movq %r9, %rdi
callq 0x30c0
movq %rax, %r13
callq 0x5481
movsd %xmm0, 0x20(%rsp)
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
leaq 0x8(%r15), %rbx
cmpq %rbp, %r14
je 0x38a9
movq -0x8(%rbx), %rdi
movl (%rbx), %esi
movq 0x18(%rsp), %rdx
movl %r13d, %ecx
callq *%r12
movq 0x60(%rsp), %rcx
movq (%rcx,%rbp,8), %rcx
cmpq %rax, %rcx
jne 0x3908
incq %rbp
addq $0x10, %rbx
jmp 0x387c
xorl %ecx, %ecx
movl 0xc(%rsp), %eax
testl %eax, %eax
cmovlel %ecx, %eax
shlq $0x3, %r14
movl %eax, 0xc(%rsp)
cmpl %eax, %ecx
je 0x3998
movq %rcx, 0x10(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x38fb
movq 0x60(%rsp), %rax
movq (%rax,%rbx), %rbp
movq (%r15,%rbx,2), %rdi
movl 0x8(%r15,%rbx,2), %esi
movq 0x18(%rsp), %rdx
movl %r13d, %ecx
callq *%r12
addq $0x8, %rbx
cmpq %rax, %rbp
je 0x38cb
jmp 0x3985
movq 0x10(%rsp), %rcx
incl %ecx
movl 0xc(%rsp), %eax
jmp 0x38bc
movq 0x66d1(%rip), %rdx      # 0x9fe0
movq (%rdx), %r15
movq -0x8(%rbx), %rdi
movq (%rbx), %r14
movq %rcx, %rdx
subq %rdi, %rdx
cmpq $0x1, %rcx
movl $0x0, %r12d
sbbq %r12, %r12
orq %rdx, %r12
movq %rax, %rcx
subq %rdi, %rcx
cmpq $0x1, %rax
movl $0x0, %ebx
sbbq %rbx, %rbx
orq %rcx, %rbx
movl %r14d, %esi
callq 0x43d0
movq %rax, %r13
subq $0x8, %rsp
leaq 0x3810(%rip), %rsi      # 0x716a
movq %r15, %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl %ebp, %r8d
movq %r12, %r9
xorl %eax, %eax
pushq %r13
pushq %r14
pushq %rbx
callq 0x32a0
addq $0x20, %rsp
movq %r13, %rdi
callq 0x3230
xorpd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5481
subsd 0x20(%rsp), %xmm0
jmp 0x3989
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/acstr.c
// Function: acstr
char *acstr(char const *buf, int len)
{
    int        i, wid = 3;
    //  Trailing NULs are ignored.
    while (len > 0 && !buf[len-1]) --len;

    for (i = 0; i < len; ++i)
        wid += esc[(unsigned char)buf[i]] ? 2 : isgraph(buf[i]) ? 1 : 4;
    char        *ret = (char *) malloc(wid + 1), *cp = ret, ec;
    *cp++ = '"';
    for (i = 0; i < len; i++) {
        if ((ec = esc[(unsigned char)buf[i]]))
            *cp++ = '\\', *cp++ = ec;
        else if (buf[i] == ' ' || isgraph(buf[i]))
            *cp++ = buf[i];
        else
            cp += sprintf(cp, "\\x%2.2X", (unsigned char)buf[i]);
    }

    *cp++ = '"';
    *cp = 0;
    return      ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %ebp
sarl $0x1f, %ebp
andl %esi, %ebp
testl %esi, %esi
jle 0x43f8
movl %esi, %eax
cmpb $0x0, -0x1(%rbx,%rax)
jne 0x43f6
decl %esi
jmp 0x43e5
movl %esi, %ebp
xorl %r15d, %r15d
testl %ebp, %ebp
cmovlel %r15d, %ebp
pushq $0x3
popq %r14
leaq 0x2da4(%rip), %r12      # 0x71b0
pushq $0x2
popq %r13
cmpq %r15, %rbp
je 0x444f
movzbl (%rbx,%r15), %eax
cmpb $0x0, (%rax,%r12)
movl %r13d, %ecx
jne 0x4447
movsbq %al, %r12
callq 0x31d0
movq (%rax), %rax
xorl %ecx, %ecx
cmpw $0x0, (%rax,%r12,2)
leaq 0x2d71(%rip), %r12      # 0x71b0
setns %cl
leal (%rcx,%rcx,2), %ecx
incl %ecx
addl %ecx, %r14d
incq %r15
jmp 0x4410
incl %r14d
movq %r14, %rdi
callq 0x3260
movq %rax, %r15
movb $0x22, (%rax)
movq %rax, (%rsp)
incq %r15
xorl %r14d, %r14d
cmpq %r14, %rbp
je 0x44d2
movzbl (%rbx,%r14), %r13d
movb (%r13,%r12), %al
testb %al, %al
je 0x448b
movb $0x5c, (%r15)
movb %al, 0x1(%r15)
addq $0x2, %r15
jmp 0x44cd
cmpb $0x20, %r13b
je 0x44c7
movsbq %r13b, %r12
callq 0x31d0
movq (%rax), %rax
cmpw $0x0, (%rax,%r12,2)
leaq 0x2d06(%rip), %r12      # 0x71b0
js 0x44c7
movq %r15, %rdi
leaq 0x2ce8(%rip), %rsi      # 0x719e
movl %r13d, %edx
xorl %eax, %eax
callq 0x3060
cltq
addq %rax, %r15
jmp 0x44cd
movb %r13b, (%r15)
incq %r15
incq %r14
jmp 0x446a
movw $0x22, (%r15)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/Server.cpp
// Function: Warp10::Server::onShutdown(u::Object*)
void Server::onShutdown(Object *arg)
{
	arg->destroy();

	trace(className() + ": Server shutting down.");
	lock();
	_isShuttingDown = true;
	unlock();

	_manager.dispatchEvent(
		new u::Network::Event(u::Network::Event::CLOSE)
	)->destroy();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1c16fd(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r14
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rsi
leaq 0x1c1714(%rip), %rdx    # 0x5c70ca
movq %rsp, %rdi
callq 0x405349
movq %rsp, %rsi
movq %r14, %rdi
callq 0x49c3f0
leaq 0x1c16db(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
movq %rsp, %rdi
callq 0x499a70
leaq 0x20(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x40c442
movb $0x1, 0x228(%rbx)
movq %rbx, %rdi
callq 0x40c3fe
movl $0xb8, %edi
callq 0x420b40
movq %rax, %r14
movq $0x64dbe8, %rsi         # imm = 0x64DBE8
movq %rax, %rdi
callq 0x40ffe2
addq $0xc0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40ad2c
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0xb8, %esi
movq %r14, %rdi
callq 0x41fb60
jmp 0x405a73
movq %rax, %rbx
jmp 0x405a69
movq %rax, %rbx
movq %rsp, %rdi
callq 0x499a70
leaq 0x20(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/Server.cpp
// Function: Warp10::Server::onManagerClosed(u::Object*)
void Server::onManagerClosed(Object* arg)
{
	arg->destroy();
	lock();
	bool shutdown = _isShuttingDown == true;
	unlock();
	if (shutdown) {
		trace(className() + "::onManagerClosed: All closed. Exit program.");
		programExit();
	} else {
		error(className() + "::onManagerClosed: Unexpected closing.");
		this->shutdown();
		//trace(className() + ": All closed. Continue program.");
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x40c442
movb 0x228(%rbx), %bpl
movq %rbx, %rdi
callq 0x40c3fe
cmpb $0x1, %bpl
jne 0x405b2b
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1c15d4(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r14
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rsi
leaq 0x1c1647(%rip), %rdx    # 0x5c7126
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x49c3f0
leaq 0x1c15ae(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x405d74
jmp 0x405ba5
movq $0x64eb00, %rdi         # imm = 0x64EB00
leaq 0x1c161a(%rip), %rsi    # 0x5c7153
callq 0x489b70
movq %rax, %r14
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rsi
leaq 0x1c1600(%rip), %rdx    # 0x5c715b
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x49c3f0
leaq 0x1c1532(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x405d1e
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x405bb3
movq %rax, %rbx
jmp 0x405bc7
jmp 0x405bba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/Server.cpp
// Function: Warp10::Server::~Server()
Server::~Server()
{
	_webService->destroy();
	
	_room.removeEventListener(
		ServerEvent::SHUTDOWN, 
		Callback(this, cb_cast(&Server::onShutdown))
	);

	_manager.removeEventListener(
		u::Network::Event::CLOSED, 
		Callback(this, cb_cast(&Server::onManagerClosed))
	);

	trace(className() + ": Server is down.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
leaq 0x23d0f0(%rip), %rax    # 0x642ce0
movq %rax, (%rdi)
movq 0x230(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x292(%rip), %rdx      # 0x405974
leaq 0xd8(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
leaq 0x38(%rbx), %rdi
movq $0x64d5d0, %rsi         # imm = 0x64D5D0
leaq 0xd8(%rsp), %rdx
callq 0x40ac48
leaq 0xd8(%rsp), %rdi
callq 0x40c544
leaq -0x1cb(%rip), %rdx      # 0x405a7c
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
leaq 0xc0(%rbx), %r14
movq $0x64dc40, %rsi         # imm = 0x64DC40
leaq 0x80(%rsp), %rdx
movq %r14, %rdi
callq 0x40ac48
leaq 0x80(%rsp), %rdi
callq 0x40c544
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1c13fc(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r15
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rsi
leaq 0x1c1401(%rip), %rdx    # 0x5c70b8
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x49c3f0
leaq 0x1c13d6(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
movq %r14, %rdi
callq 0x4102b6
movq %rbx, %rdi
callq 0x40d798
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x4052dd
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/Server.cpp
// Function: Warp10::Server::shutdown()
void Server::shutdown()
{
	// tell the network for shutdown
	_room.dispatchEvent(
		new ServerEvent(ServerEvent::SHUTDOWN)
	)->destroy();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x420b40
movq %rax, %rbx
movq $0x64d5d0, %rsi         # imm = 0x64D5D0
movq %rax, %rdi
callq 0x405f04
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40ad2c
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx)
movq %rax, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x41fb60
movq %r14, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/Server.cpp
// Function: Warp10::Server::programExit()
void Server::programExit()
{
	lock();	unlock(); // wait for other progress(es)
	trace(
		//ThreadSystem::toString()+"\n" + 
		className() + ": Exit programm."
	);
	u::programExit();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
callq 0x40c442
movq %r14, %rdi
callq 0x40c3fe
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1c12f8(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %rbx
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rsi
leaq 0x1c1327(%rip), %rdx    # 0x5c70e2
movq %rsp, %rdi
callq 0x405349
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x49c3f0
leaq 0x1c12d6(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
movq %rsp, %rdi
callq 0x499a70
leaq 0x20(%rsp), %rdi
callq 0x4050e8
callq 0x404f28
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x405e14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x499a70
leaq 0x20(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/WebService.cpp
// Function: Warp10::WebService::WebService(u::Network::Manager*, u::String, long)
WebService::WebService(Manager* manager, String address, int64 port) : Object()
{
	_manager = manager;
	_address = address;
	_port   = port;

	_builder.setupListener(_address, _port);
	_builder.networkType = type;

	_manager->addEventListener(
		u::Network::Event::NETWORK_REGISTERED,
		Callback(this, cb_cast(&WebService::onNetworkRegistered))
	);
	_manager->addEventListener(
		u::Network::Event::LISTENER_CREATED,
		Callback(this, cb_cast(&WebService::onListenerCreated))
	);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x40c488
leaq 0x23cdb7(%rip), %rax    # 0x642d78
movq %rax, (%rbx)
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x4068d8
leaq 0x130(%rbx), %r15
movq %r15, %rdi
callq 0x40c8e2
movq %rbp, 0x38(%rbx)
movq %r15, %rdi
movq %r13, %rsi
callq 0x40cbf6
movq %r12, 0x188(%rbx)
leaq 0xb0(%rsp), %rdi
movq %r15, %rsi
callq 0x40cb38
movq 0x188(%rbx), %rdx
leaq 0xb0(%rsp), %rsi
movq %r14, %rdi
callq 0x406bca
leaq 0xb0(%rsp), %rdi
callq 0x4050e8
leaq 0xd8(%rbx), %rdi
leaq 0x2476a9(%rip), %rsi    # 0x64d6e0
callq 0x40cbf6
movq 0x38(%rbx), %r12
leaq 0x58(%rsp), %rdi
pushq $0x29
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64db38, %rsi         # imm = 0x64DB38
leaq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x40abb6
leaq 0x58(%rsp), %rdi
callq 0x40c544
movq 0x38(%rbx), %r12
movq %rsp, %rdi
pushq $0x31
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64db90, %rsi         # imm = 0x64DB90
movq %rsp, %rdx
movq %r12, %rdi
callq 0x40abb6
movq %rsp, %rdi
callq 0x40c544
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rsp, %rdi
jmp 0x4060c6
movq %rax, %r12
leaq 0x58(%rsp), %rdi
callq 0x40c544
jmp 0x4060ec
movq %rax, %r12
leaq 0xb0(%rsp), %rdi
callq 0x4050e8
jmp 0x4060ec
movq %rax, %r12
jmp 0x4060f4
movq %rax, %r12
jmp 0x4060fc
movq %rax, %r12
movq %r15, %rdi
callq 0x4050e8
movq %r14, %rdi
callq 0x406940
movq %rbx, %rdi
callq 0x40c544
movq %r12, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/WebService.cpp
// Function: Warp10::WebService::~WebService()
WebService::~WebService()
{
	_manager->removeEventListener(
		u::Network::Event::NETWORK_REGISTERED,
		Callback(this, cb_cast(&WebService::onNetworkRegistered))
	);
	_manager->removeEventListener(
		u::Network::Event::LISTENER_CREATED,
		Callback(this, cb_cast(&WebService::onListenerCreated))
	);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x23cc58(%rip), %rax    # 0x642d78
movq %rax, (%rdi)
movq 0x38(%rdi), %r14
leaq 0x60(%rsp), %rdi
pushq $0x29
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64db38, %rsi         # imm = 0x64DB38
leaq 0x60(%rsp), %rdx
movq %r14, %rdi
callq 0x40ac48
leaq 0x60(%rsp), %rdi
callq 0x40c544
movq 0x38(%rbx), %r14
leaq 0x8(%rsp), %rdi
pushq $0x31
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64db90, %rsi         # imm = 0x64DB90
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x40ac48
leaq 0x8(%rsp), %rdi
callq 0x40c544
leaq 0x130(%rbx), %rdi
callq 0x4050e8
leaq 0x40(%rbx), %rdi
callq 0x406940
movq %rbx, %rdi
callq 0x40c544
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4052dd
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/warp10server/src/WebService.cpp
// Function: Warp10::WebService::onNetworkRegistered(u::Object*)
void WebService::onNetworkRegistered(Object* arg)
{
	u::Network::Event* event = ((u::Network::Event*)arg);
	if (event->networkType == type) {
		u::Network::Event requestListener(
			u::Network::Event::REQUEST_LISTENER, type
		);
		lock();
		_manager->dispatchEvent(&requestListener);
		unlock();
	}
	event->destroy();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x90(%rsi), %rdi
leaq 0x247508(%rip), %rsi    # 0x64d718
callq 0x406883
testb %al, %al
je 0x40626f
leaq 0x2474c0(%rip), %rsi    # 0x64d6e0
movq %rsp, %r15
movq %r15, %rdi
callq 0x40cb38
movq $0x64dae0, %rsi         # imm = 0x64DAE0
leaq 0x58(%rsp), %rdi
movq %r15, %rdx
callq 0x40ff84
movq %rsp, %rdi
callq 0x4050e8
movq %r14, %rdi
callq 0x40c442
movq 0x38(%r14), %rdi
leaq 0x58(%rsp), %rsi
callq 0x40ad2c
movq %r14, %rdi
callq 0x40c3fe
leaq 0x58(%rsp), %rdi
callq 0x4100e2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4050e8
jmp 0x40629e
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x4100e2
movq %rbx, %rdi
callq 0x4ca950