LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
cmpb $0x0, 0x40(%rdi)
je 0x99f4
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
je 0x9a09
leaq 0xa0(%rbx), %rsi
leaq 0x88(%rbx), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd6ba
movq 0x70(%rbx), %r12
cmpq %r12, 0x78(%rbx)
je 0x995f
movl $0x30, %r14d
xorl %r15d, %r15d
leaq 0x10(%rsp), %rbp
leaq (%r12,%r14), %r13
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq -0x30(%r12,%r14), %rsi
movq -0x28(%r12,%r14), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x4cae
movups -0x10(%r12,%r14), %xmm0
leaq 0x20(%rsp), %rax
movups %xmm0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x4b20
movq %rbx, %rdi
movq %rbp, %r13
movq %rbp, %rsi
callq 0x933c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x991b
callq 0x21c0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x992f
callq 0x21c0
incq %r15
movq 0x70(%rbx), %r12
movq 0x78(%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rax
addq $0x48, %r14
cmpq %r15, %rax
movq %r13, %rbp
ja 0x98bf
movq 0x8(%rsp), %rdi
callq *0x48(%rbx)
movq 0x88(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
shlq $0x1d, %rax
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %rax, %rdx
sarq $0x1d, %rdx
movsd (%rcx,%rdx), %xmm0
andps 0x6907(%rip), %xmm0     # 0x102a0
movlps %xmm0, 0x38(%rbx)
leaq 0xd0(%rbx), %rsi
movq %rbx, %rdi
callq 0x6152
leaq 0x100(%rbx), %rsi
movq %rbx, %rdi
callq 0x62d4
leaq 0x148(%rbx), %rsi
movq %rbx, %rdi
callq 0x64fc
leaq 0x178(%rbx), %rsi
movq %rbx, %rdi
callq 0x6674
movb $0x1, 0x42(%rbx)
movq %rbx, %rdi
callq 0x9a8e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb5dd(%rip), %rdi      # 0x14fd8
leaq 0x696a(%rip), %rsi      # 0x1036c
callq 0x21e0
jmp 0x9a24
movq 0xb5c8(%rip), %rdi      # 0x14fd8
leaq 0x6984(%rip), %rsi      # 0x1039b
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9a51
callq 0x21c0
jmp 0x9a51
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x49b6
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq %edx, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
decq %rdx
cmpq %rax, %rdx
jb 0xcbf7
movq %rdi, %rbx
shlq $0x5, %rax
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
callq 0x4cae
movq %rbx, %rax
popq %rbx
retq
movq 0x83da(%rip), %rdi      # 0x14fd8
leaq 0x3999(%rip), %rsi      # 0x1059e
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58fa
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq *0x48(%rbx)
movq %rbx, %rdi
callq 0xccb2
leaq 0xa0(%rbx), %rdi
movq %r14, %rsi
callq 0xd6ba
movq 0x88(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
shlq $0x1d, %rax
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %rax, %rdx
sarq $0x1d, %rdx
movsd (%rcx,%rdx), %xmm0
andps 0x3624(%rip), %xmm0     # 0x102a0
movlps %xmm0, 0x30(%rbx)
leaq 0xb8(%rbx), %rsi
movq %rbx, %rdi
callq 0x6152
leaq 0xe8(%rbx), %rsi
movq %rbx, %rdi
callq 0x62d4
movb $0x1, 0x40(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68cc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
movq %rsi, %rax
subq 0x20(%rdi), %rax
sarq $0x3, %rax
incq %rax
movslq (%rdi), %rcx
cmpq %rcx, %rax
ja 0xd1be
cmpq 0x30(%rdi), %rsi
je 0xd1b0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rdi)
jmp 0xd1bc
addq $0x20, %rdi
movq %rsp, %rdx
callq 0xe388
popq %rax
retq
movq 0x7e13(%rip), %rdi      # 0x14fd8
leaq 0x314c(%rip), %rsi      # 0x10318
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e52(%rip), %rsi      # 0x100a1
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0xd2ca
leaq 0x2e3a(%rip), %rsi      # 0x1009c
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0xd2de
leaq 0x2e2b(%rip), %rsi      # 0x100a0
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0xd2f2
movq 0x7d50(%rip), %rbx      # 0x14fd8
leaq 0x3071(%rip), %rsi      # 0x10300
movl $0x17, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2120
movl $0x0, 0x20(%rbx)
jmp 0xd304
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2120
movl $0x1, 0x20(%rbx)
jmp 0xd304
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2120
movl $0xffffffff, 0x20(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq %esi, %rcx
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %r8
movslq %edx, %rcx
movq (%rax,%r8,8), %rdx
movq 0x8(%rax,%r8,8), %r8
subq %rdx, %r8
je 0xf1f6
movsd 0xea4(%rip), %xmm0      # 0x10050
divsd (%rdx,%rcx,8), %xmm0
sarq $0x3, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movapd 0x10d8(%rip), %xmm1     # 0x102a0
movsd 0x1100(%rip), %xmm2     # 0x102d0
movsd (%rdx,%r9,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
ucomisd %xmm4, %xmm2
jae 0xf1ee
mulsd %xmm0, %xmm3
movsd %xmm3, (%rdx,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0xf1d0
movq 0x8(%rdi), %r8
subq %rax, %r8
je 0xf28f
sarq $0x3, %r8
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %r8, %rdi
cmpq $0x1, %rdi
adcq $0x0, %rdi
movl %esi, %esi
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
movapd 0x1082(%rip), %xmm1     # 0x102b0
cmpq %rsi, %r8
je 0xf287
leaq (%r8,%r8,2), %r10
movq (%rax,%r10,8), %r9
movsd (%r9,%rcx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0xf249
jnp 0xf287
leaq (%rax,%r10,8), %r10
movq 0x8(%r10), %r10
subq %r9, %r10
je 0xf287
xorpd %xmm1, %xmm2
sarq $0x3, %r10
cmpq $0x1, %r10
adcq $0x0, %r10
xorl %r11d, %r11d
movsd (%rdx,%r11,8), %xmm3
mulsd %xmm2, %xmm3
addsd (%r9,%r11,8), %xmm3
movsd %xmm3, (%r9,%r11,8)
incq %r11
cmpq %r11, %r10
jne 0xf269
incq %r8
cmpq %rdi, %r8
jne 0xf22e
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0xf2cb
xorpd %xmm0, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm1, %xmm0
cmoval %esi, %eax
minsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
cmpq %rsi, %rdx
jne 0xf2ae
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b20
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
decq %rax
je 0xf3b6
xorpd %xmm0, %xmm0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
cmoval %ecx, %ebp
minsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
cmpq %rcx, %rax
jne 0xf398
jmp 0xf3bb
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0xf3c5
callq 0x21c0
cmpl $-0x1, %ebp
je 0xf3e2
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf2d1
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0xf189
jmp 0xf36c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq (%rsi,%rsi,2), %rsi
movq (%rax,%rsi,8), %rsi
movsd 0x122a(%rip), %xmm0     # 0x106c0
xorl %edi, %edi
xorpd %xmm1, %xmm1
movapd 0xdfc(%rip), %xmm2      # 0x102a0
movsd (%rsi,%rdi,8), %xmm3
ucomisd %xmm1, %xmm3
jae 0xf4cb
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
cmpq %rdi, %rdx
jne 0xf4a4
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
callq 0xf3eb
cmpl $-0x1, %eax
je 0xf50b
movl %eax, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf46f
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xf189
movq %rbx, %rdi
callq 0xf3eb
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0xf4e6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0xf4d4
xorl %edx, %edx
xorpd %xmm0, %xmm0
movl $0x1, %esi
xorl %r8d, %r8d
ucomisd (%rax,%rdx,8), %xmm0
movzbl %r8b, %r8d
cmoval %esi, %r8d
incq %rdx
cmpq %rdx, %rcx
jne 0xf53a
testb $0x1, %r8b
je 0xf4d4
jmp 0xf35c
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x4(%rsp)
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %r9, %rdi
callq 0x30c0
movq %rax, %r13
callq 0x56fe
movsd %xmm0, 0x20(%rsp)
movl %ebp, %r14d
movl %ebp, 0x1c(%rsp)
testl %ebp, %ebp
jle 0x3963
xorl %ebp, %ebp
movq %rbx, %r15
movq (%r15), %rdi
movl 0x8(%r15), %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
callq *%r12
movq 0x60(%rsp), %rcx
movq (%rcx,%rbp,8), %rcx
cmpq %rax, %rcx
jne 0x39c6
incq %rbp
addq $0x10, %r15
cmpq %rbp, %r14
jne 0x3937
cmpl $0x0, 0x4(%rsp)
jle 0x39b9
shlq $0x3, %r14
xorl %eax, %eax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x39ac
xorl %ebp, %ebp
movq 0x60(%rsp), %rax
movq (%rax,%rbp), %r15
movq (%rbx,%rbp,2), %rdi
movl 0x8(%rbx,%rbp,2), %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
callq *%r12
cmpq %rax, %r15
jne 0x3a40
addq $0x8, %rbp
cmpq %rbp, %r14
jne 0x397e
movq 0x8(%rsp), %rax
incl %eax
cmpl 0x4(%rsp), %eax
jne 0x3970
callq 0x56fe
subsd 0x20(%rsp), %xmm0
jmp 0x3a44
movq 0x6613(%rip), %rdx      # 0x9fe0
movq $-0x1, %rsi
movq $-0x1, %r14
testq %rcx, %rcx
je 0x39e6
subq (%r15), %rcx
movq %rcx, %r14
movq (%rdx), %rbx
testq %rax, %rax
je 0x39f4
subq (%r15), %rax
movq %rax, %rsi
movq (%r15), %rdi
movq 0x8(%r15), %r12
movq %rsi, %r15
movl %r12d, %esi
callq 0x4564
movq %rax, %r13
subq $0x8, %rsp
leaq 0x3759(%rip), %rsi      # 0x716d
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl %ebp, %r8d
movq %r14, %r9
xorl %eax, %eax
pushq %r13
pushq %r12
pushq %r15
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
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %r14d
movq %rdi, %rbx
testl %esi, %esi
jle 0x4593
movl %r14d, %eax
cmpb $0x0, -0x1(%rbx,%rax)
jne 0x4593
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x4579
xorl %r14d, %r14d
movl %r14d, %ebp
testl %r14d, %r14d
jle 0x4600
movl $0x3, %r15d
xorl %r12d, %r12d
leaq 0x2c05(%rip), %rdx      # 0x71b0
movzbl (%rbx,%r12), %ecx
movl $0x2, %eax
cmpb $0x0, (%rcx,%rdx)
jne 0x45f0
movsbq %cl, %rax
movq %rax, (%rsp)
movq %rbx, %r13
movq %rbp, %rbx
movq %rdx, %rbp
callq 0x31d0
movq %rbp, %rdx
movq %rbx, %rbp
movq %r13, %rbx
movq (%rax), %rax
xorl %ecx, %ecx
movq (%rsp), %rsi
cmpw $0x0, (%rax,%rsi,2)
setns %cl
leal (%rcx,%rcx,2), %eax
incl %eax
addl %eax, %r15d
incq %r12
cmpq %r12, %rbp
jne 0x45ab
incl %r15d
jmp 0x4606
movl $0x4, %r15d
movq %r15, %rdi
callq 0x3260
movq %rax, %r12
movb $0x22, (%rax)
movq %rax, (%rsp)
incq %r12
testl %r14d, %r14d
jle 0x4693
leaq 0x2b89(%rip), %r14      # 0x71b0
xorl %r15d, %r15d
movzbl (%rbx,%r15), %r13d
movb (%r13,%r14), %al
testb %al, %al
je 0x4648
movb $0x5c, (%r12)
movb %al, 0x1(%r12)
addq $0x2, %r12
jmp 0x468b
cmpb $0x20, %r13b
je 0x4684
movsbq %r13b, %r14
callq 0x31d0
movq (%rax), %rax
cmpw $0x0, (%rax,%r14,2)
leaq 0x2b49(%rip), %r14      # 0x71b0
js 0x4684
movq %r12, %rdi
leaq 0x2b2e(%rip), %rsi      # 0x71a1
movl %r13d, %edx
xorl %eax, %eax
callq 0x3060
cltq
addq %rax, %r12
jmp 0x468b
movb %r13b, (%r12)
incq %r12
incq %r15
cmpq %r15, %rbp
jne 0x462a
movw $0x22, (%r12)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c8492(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490a00
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c84a7(%rip), %rsi    # 0x5ce0ca
callq 0x4a25e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x405c4f
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x405c56
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490a00
movq %rax, %r14
leaq 0x1c841d(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490a00
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471b50
movsbl %al, %esi
movq %r14, %rdi
callq 0x490500
movq %rax, %rdi
callq 0x48fad0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x405cd9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x405cf4
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x28(%rsp), %rdi
callq 0x410354
movq %rbx, %rdi
callq 0x410246
movb $0x1, 0x228(%rbx)
movq %rbx, %rdi
callq 0x4101fe
movl $0xb8, %edi
callq 0x427f00
movq %rax, %r14
movq $0x652c08, %rsi         # imm = 0x652C08
movq %rax, %rdi
callq 0x4168dc
addq $0xc0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e18e
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xb8, %esi
movq %r14, %rdi
callq 0x426f20
jmp 0x405d93
movq %rax, %rbx
jmp 0x405d89
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x405d89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x28(%rsp), %rdi
callq 0x40512a
movq %rbx, %rdi
callq 0x4d11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0x241d2a(%rip), %rax    # 0x647d80
movq %rax, (%rdi)
movq 0x230(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x492(%rip), %rdx      # 0x405bda
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
leaq 0x38(%rbx), %rdi
movq $0x6525f0, %rsi         # imm = 0x6525F0
leaq 0xd0(%rsp), %rdx
callq 0x40e05e
leaq 0xd0(%rsp), %rdi
callq 0x410354
leaq -0x311(%rip), %rdx      # 0x405d9c
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
leaq 0xc0(%rbx), %r14
movq $0x652c60, %rsi         # imm = 0x652C60
leaq 0x78(%rsp), %rdx
movq %r14, %rdi
callq 0x40e05e
leaq 0x78(%rsp), %rdi
callq 0x410354
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c7f9f(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490a00
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x1c7fa2(%rip), %rsi    # 0x5ce0b8
callq 0x4a25e0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x406142
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x40614a
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490a00
movq %rax, %r15
leaq 0x1c7f2a(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490a00
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x471b50
movsbl %al, %esi
movq %r15, %rdi
callq 0x490500
movq %rax, %rdi
callq 0x48fad0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4061cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4061e6
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x20(%rsp), %rdi
callq 0x410354
movq %r14, %rdi
callq 0x416c42
movq %rbx, %rdi
callq 0x411b7c
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x405457
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x50, %edi
callq 0x427f00
movq %rax, %rbx
movq $0x6525f0, %rsi         # imm = 0x6525F0
movq %rax, %rdi
callq 0x406594
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40e18e
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx)
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
callq 0x426f20
movq %r14, %rdi
callq 0x4d11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
callq 0x410246
movq %rbx, %rdi
callq 0x4101fe
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c7dfa(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490a00
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x1c7e27(%rip), %rsi    # 0x5ce0e2
callq 0x4a25e0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4062e6
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x4062ed
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490a00
movq %rax, %rbx
leaq 0x1c7d87(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490a00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x471b50
movsbl %al, %esi
movq %rbx, %rdi
callq 0x490500
movq %rax, %rdi
callq 0x48fad0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40636e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406389
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x20(%rsp), %rdi
callq 0x410354
callq 0x404f28
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x4063be
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4063be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x20(%rsp), %rdi
callq 0x40512a
movq %rbx, %rdi
callq 0x4d11b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41028c
leaq 0x2417ab(%rip), %rax    # 0x647e18
movq %rax, (%rbx)
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x40735c
leaq 0x130(%rbx), %r15
movq %r15, %rdi
callq 0x4107d2
movq %rbp, 0x38(%rbx)
movq %r15, %rdi
movq %r13, %rsi
callq 0x410b12
movq %r12, 0x188(%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x410a3a
movq 0x188(%rbx), %rdx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40791e
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4066d9
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x426f20
movq %rsp, %rdi
callq 0x410354
leaq 0xd8(%rbx), %rdi
leaq 0x24c011(%rip), %rsi    # 0x652700
callq 0x410b12
movq 0x38(%rbx), %r12
leaq 0xb0(%rsp), %rdi
movl $0x29, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652b58, %rsi         # imm = 0x652B58
leaq 0xb0(%rsp), %rdx
movq %r12, %rdi
callq 0x40dfba
leaq 0xb0(%rsp), %rdi
callq 0x410354
movq 0x38(%rbx), %r12
leaq 0x58(%rsp), %rdi
movl $0x31, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652bb0, %rsi         # imm = 0x652BB0
leaq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x40dfba
leaq 0x58(%rsp), %rdi
callq 0x410354
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x58(%rsp), %rdi
jmp 0x406796
movq %rax, %r12
leaq 0xb0(%rsp), %rdi
callq 0x410354
jmp 0x4067b7
movq %rax, %r12
movq %rsp, %rdi
callq 0x40512a
jmp 0x4067b7
movq %rax, %r12
jmp 0x4067bf
movq %rax, %r12
jmp 0x4067c7
movq %rax, %r12
movq %r15, %rdi
callq 0x40512a
movq %r14, %rdi
callq 0x4073c4
movq %rbx, %rdi
callq 0x410354
movq %r12, %rdi
callq 0x4d11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24162c(%rip), %rax    # 0x647e18
movq %rax, (%rdi)
movq 0x38(%rdi), %r14
leaq 0x60(%rsp), %rdi
movl $0x29, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652b58, %rsi         # imm = 0x652B58
leaq 0x60(%rsp), %rdx
movq %r14, %rdi
callq 0x40e05e
leaq 0x60(%rsp), %rdi
callq 0x410354
movq 0x38(%rbx), %r14
leaq 0x8(%rsp), %rdi
movl $0x31, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652bb0, %rsi         # imm = 0x652BB0
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x40e05e
leaq 0x8(%rsp), %rdi
callq 0x410354
movq 0x168(%rbx), %rdi
leaq 0x178(%rbx), %rax
cmpq %rax, %rdi
je 0x40687f
movq (%rax), %rsi
incq %rsi
callq 0x426f20
leaq 0x130(%rbx), %rdi
callq 0x410354
leaq 0x40(%rbx), %rdi
callq 0x4073c4
movq %rbx, %rdi
callq 0x410354
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x405457
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98(%rsi), %rdx
cmpq 0x24be45(%rip), %rdx    # 0x652740
jne 0x406991
movq %rdi, %r14
testq %rdx, %rdx
je 0x406920
movq 0x24be28(%rip), %rsi    # 0x652738
movq 0x90(%rbx), %rdi
callq 0x401090
testl %eax, %eax
jne 0x406991
leaq 0x24bdd9(%rip), %rsi    # 0x652700
movq %rsp, %r15
movq %r15, %rdi
callq 0x410a3a
movq $0x652b00, %rsi         # imm = 0x652B00
leaq 0x58(%rsp), %rdi
movq %r15, %rdx
callq 0x41687e
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406961
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x426f20
movq %rsp, %rdi
callq 0x410354
movq %r14, %rdi
callq 0x410246
movq 0x38(%r14), %rdi
leaq 0x58(%rsp), %rsi
callq 0x40e18e
movq %r14, %rdi
callq 0x4101fe
leaq 0x58(%rsp), %rdi
callq 0x4169fc
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 0x40512a
jmp 0x4069c0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x4169fc
movq %rbx, %rdi
callq 0x4d11b0
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/WebService.cpp
// Function: Warp10::WebService::registerNetwork()
void WebService::registerNetwork()
{
	u::Network::Event registerNetwork(
		u::Network::Event::REGISTER_NETWORK, type, &_builder
	);
	lock();
	_manager->dispatchEvent(&registerNetwork);
	unlock();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x24baee(%rip), %rsi    # 0x652700
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x410a3a
leaq 0x40(%rbx), %rcx
movq $0x652aa8, %rsi         # imm = 0x652AA8
leaq 0x60(%rsp), %rdi
movq %r14, %rdx
callq 0x41672c
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406c52
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x8(%rsp), %rdi
callq 0x410354
movq %rbx, %rdi
callq 0x410246
movq 0x38(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0x40e18e
movq %rbx, %rdi
callq 0x4101fe
leaq 0x60(%rsp), %rdi
callq 0x4169fc
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40512a
jmp 0x406cab
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x4169fc
movq %rbx, %rdi
callq 0x4d11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/WebService.cpp
// Function: Warp10::WebService::onListenerClose(u::Object*)
void WebService::onListenerClose(Object* arg)
{
	WebEvent* event = ((WebEvent*)arg);
	IListener* listener = ((IListener*)event->target());
	listener->removeEventListener(
		WebEvent::INCOMMING_CONNECTION,
		Callback(this, cb_cast(&WebService::onNewConnection))
	);
	listener->removeEventListener(
		WebEvent::WILL_CLOSE,
		Callback(this, cb_cast(&WebService::onListenerClose))
	);
	event->destroy();

	WebEvent canClose(WebEvent::CAN_CLOSE);
	listener->dispatchEvent(&canClose);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x40c3b8
movq %rax, %rbx
leaq 0x60(%rsp), %r12
movl $0x41, %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652768, %rsi         # imm = 0x652768
movq %rbx, %rdi
movq %r12, %rdx
callq 0x40e05e
leaq 0x60(%rsp), %rdi
callq 0x410354
leaq 0x8(%rsp), %r12
movl $0x39, %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x6527c0, %rsi         # imm = 0x6527C0
movq %rbx, %rdi
movq %r12, %rdx
callq 0x40e05e
leaq 0x8(%rsp), %rdi
callq 0x410354
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq $0x652818, %rsi         # imm = 0x652818
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
callq 0x409104
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e18e
leaq 0xb8(%rsp), %rdi
callq 0x40904a
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x40904a
jmp 0x406dae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x406da9
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x410354
movq %rbx, %rdi
callq 0x4d11b0
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/WebService.cpp
// Function: Warp10::WebService::onNewConnection(u::Object*)
void WebService::onNewConnection(Object* arg)
{
	Network::WebEvent* event  = ((Network::WebEvent*)arg);
	WebConnection* connection = ((WebConnection*)event->connection);
	connection->addEventListener(
		WebEvent::REQUEST,
		Callback(this, cb_cast(&WebService::onRequest))
	);
	connection->read();
	event->destroy();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x48(%rbx), %r14
leaq 0x8(%rsp), %r15
movl $0x49, %edx
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652870, %rsi         # imm = 0x652870
movq %r14, %rdi
movq %r15, %rdx
callq 0x40dfba
leaq 0x8(%rsp), %rdi
callq 0x410354
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x410354
movq %rbx, %rdi
callq 0x4d11b0
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebBuilder.cpp
// Function: Warp10::Network::WebBuilder::setupListener(u::String, long)
void WebBuilder::setupListener(String address, int64 port)
{
	lock();
	_address = address;
	_port    = port;
	unlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x410246
leaq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0x410b12
movq %rbx, 0x90(%r15)
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4101fe
nop
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebConnection.cpp
// Function: Warp10::Network::WebConnection::WebConnection(u::Socket*)
WebConnection::WebConnection(Socket* socket) : IConnection()
{
	_isReading = false;
	_socket    = socket;
	_isClosed  = false;

	addEventListener(
		u::Network::Event::CLOSE
		, Callback(this, cb_cast(&WebConnection::onClose))
	);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x88, %edx
xorl %esi, %esi
callq 0x401098
movq %rbx, %rdi
callq 0x40fc28
leaq 0x240547(%rip), %rax    # 0x647f08
movq %rax, (%rbx)
movb %r15b, 0x88(%rbx)
movq %r14, 0x90(%rbx)
movb %r15b, 0x98(%rbx)
leaq 0x8(%rsp), %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40dfba
leaq 0x8(%rsp), %rdi
callq 0x410354
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x410354
jmp 0x407a2a
movq %rax, %r14
movq %rbx, %rdi
callq 0x40fc56
movq %r14, %rdi
callq 0x4d11b0
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebConnection.cpp
// Function: Warp10::Network::WebConnection::~WebConnection()
WebConnection::~WebConnection()
{
	removeEventListener(
		u::Network::Event::CLOSE
		, Callback(this, cb_cast(&WebConnection::onClose))
	);
	_socket->destroy();
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x2404bf(%rip), %rax    # 0x647f08
movq %rax, (%rdi)
leaq 0x8(%rsp), %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40e05e
leaq 0x8(%rsp), %rdi
callq 0x410354
movq 0x90(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x40fc56
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x405457
nop
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebConnection.cpp
// Function: Warp10::Network::WebConnection::send(u::ByteArray*)
void WebConnection::send(ByteArray* data)
{
	lock();
	Socket* socket = _socket;
	unlock();

	data->position(0);
	while(data->available())
	{
		if(socket->send(data) == -1)
		{
			error(className()+"::send() Unable to send data.");
			error("TODO CLOSE");
			/**
			Callback cb(this, cb_cast(&NetworkDecoder::doClosed));
			ThreadSystem::create(&cb);
			*/
			return;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x410246
movq 0x90(%rbx), %r15
movq %rbx, %rdi
callq 0x4101fe
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x20(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testq %rax, %rax
je 0x407fef
movq %r15, %rdi
movq %r14, %rsi
callq 0x412e4e
cmpq $-0x1, %rax
jne 0x407e59
movq $0x653b20, %rdi         # imm = 0x653B20
leaq 0x1c62c9(%rip), %rsi    # 0x5ce153
movl $0x7, %edx
callq 0x490a00
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c64af(%rip), %rsi    # 0x5ce35d
callq 0x4a25e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x407eda
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x407ee1
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq $0x653b20, %rbx         # imm = 0x653B20
movq %rbx, %rdi
callq 0x490a00
movq %rax, %r14
leaq 0x1c618f(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490a00
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471b50
movsbl %al, %esi
movq %r14, %rdi
callq 0x490500
movq %rax, %rdi
callq 0x48fad0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x407f67
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x407f82
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x28(%rsp), %rdi
callq 0x410354
leaq 0x1c61c0(%rip), %rsi    # 0x5ce153
movl $0x7, %edx
movq %rbx, %rdi
callq 0x490a00
leaq 0x1c63d4(%rip), %rsi    # 0x5ce37b
movl $0xa, %edx
movq %rbx, %rdi
callq 0x490a00
leaq 0x1c60f0(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rbx, %rdi
callq 0x490a00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x471b50
movsbl %al, %esi
movq %rbx, %rdi
callq 0x490500
movq %rax, %rdi
callq 0x48fad0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x40801b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x40801b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x28(%rsp), %rdi
callq 0x40512a
movq %rbx, %rdi
callq 0x4d11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebConnection.cpp
// Function: Warp10::Network::WebConnection::onClose(u::Object*)
void WebConnection::onClose(Object *arg)
{
	u::Network::Event* event = ((u::Network::Event*)arg);
	event->destroy();

	lock();
	if (_isClosed == false) {
		_socket->close();
	} else {
		// avoid double close
		unlock();
		return;
	}
	_isClosed  = true;
	unlock();

	u::Network::Event closed(u::Network::Event::CLOSED);
	dispatchEvent(&closed);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x410246
cmpb $0x0, 0x98(%rbx)
je 0x408066
movq %rbx, %rdi
addq $0xb8, %rsp
popq %rbx
popq %r14
jmp 0x4101fe
movq 0x90(%rbx), %rdi
callq 0x41218e
movb $0x1, 0x98(%rbx)
movq %rbx, %rdi
callq 0x4101fe
movq $0x652c60, %rsi         # imm = 0x652C60
movq %rsp, %r14
movq %r14, %rdi
callq 0x4168dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e18e
movq %rsp, %rdi
callq 0x4169fc
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4169fc
movq %rbx, %rdi
callq 0x4d11b0
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebListener.cpp
// Function: Warp10::Network::WebListener::WebListener(u::Network::IBuilder*, u::Socket*)
WebListener::WebListener(IBuilder* builder, Socket* socket) : IListener()
{
	_builder  = ((WebBuilder*)builder);
	_socket    = socket;
	_isClosed  = false;
	_closeSent = false;

	addEventListener(
		u::Network::Event::CLOSE,
		Callback(this, cb_cast(&WebListener::onClose))
	);
	addEventListener(
		WebEvent::CAN_CLOSE,
		Callback(this, cb_cast(&WebListener::onCanClose))
	);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x88, %edx
xorl %esi, %esi
callq 0x401098
movq %rbx, %rdi
callq 0x40fc28
leaq 0x23ecbc(%rip), %rax    # 0x648028
movq %rax, (%rbx)
leaq 0x98(%rbx), %r14
leaq 0xd0(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
movq $0x0, 0xe0(%rbx)
movq %r14, %rdi
callq 0x41028c
leaq 0x23ed17(%rip), %rax    # 0x6480b8
movq %rax, 0x98(%rbx)
movq %r12, 0x88(%rbx)
movq %r15, 0x90(%rbx)
movw $0x0, 0xe8(%rbx)
leaq 0x58(%rsp), %rdi
movl $0x31, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x40dfba
leaq 0x58(%rsp), %rdi
callq 0x410354
movq %rsp, %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652818, %rsi         # imm = 0x652818
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x40dfba
movq %rsp, %rdi
callq 0x410354
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rsp, %rdi
jmp 0x409444
movq %rax, %r15
leaq 0x58(%rsp), %rdi
callq 0x410354
jmp 0x40946b
movq %rax, %r15
movq (%r13), %rdi
testq %rdi, %rdi
je 0x409473
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0x426f20
jmp 0x409473
movq %rax, %r15
movq %r14, %rdi
callq 0x40a890
movq %rbx, %rdi
callq 0x40fc56
movq %r15, %rdi
callq 0x4d11b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/warp10server/src/Network/WebListener.cpp
// Function: Warp10::Network::WebListener::~WebListener()
WebListener::~WebListener()
{
	_socket->destroy();
	removeEventListener(
		u::Network::Event::CLOSE,
		Callback(this, cb_cast(&WebListener::onClose))
	);
	removeEventListener(
		WebEvent::CAN_CLOSE,
		Callback(this, cb_cast(&WebListener::onCanClose))
	);
	trace(className() + "::~WebListener: Down.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
leaq 0x23eb8e(%rip), %rax    # 0x648028
movq %rax, (%rdi)
movq 0x90(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0xd8(%rsp), %rdi
movl $0x31, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0xd8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40e05e
leaq 0xd8(%rsp), %rdi
callq 0x410354
leaq 0x80(%rsp), %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bd54
movq $0x652818, %rsi         # imm = 0x652818
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
callq 0x40e05e
leaq 0x80(%rsp), %rdi
callq 0x410354
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c4b5e(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490a00
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c4fe4(%rip), %rsi    # 0x5ce53b
callq 0x4a25e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x409583
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x40958a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490a00
movq %rax, %r14
leaq 0x1c4ae9(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490a00
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471b50
movsbl %al, %esi
movq %r14, %rdi
callq 0x490500
movq %rax, %rdi
callq 0x48fad0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x40960d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x409628
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426f20
leaq 0x28(%rsp), %rdi
callq 0x410354
leaq 0x98(%rbx), %rdi
callq 0x410354
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x409659
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0x426f20
movq %rbx, %rdi
callq 0x40fc56
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x405457