LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd33a
cmpq 0x30(%rdi), %rsi
je 0xd32c
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rdi)
jmp 0xd338
addq $0x20, %rdi
movq %rsp, %rdx
callq 0xe528
popq %rax
retq
movq 0x7c97(%rip), %rdi      # 0x14fd8
leaq 0x2fd0(%rip), %rsi      # 0x10318
callq 0x21e0
movq %rax, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cd6(%rip), %rsi      # 0x100a1
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0xd446
leaq 0x2cbe(%rip), %rsi      # 0x1009c
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0xd45a
leaq 0x2caf(%rip), %rsi      # 0x100a0
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0xd46e
movq 0x7bd4(%rip), %rbx      # 0x14fd8
leaq 0x2ef5(%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 0xd480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2120
movl $0x1, 0x20(%rbx)
jmp 0xd480
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_O3/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 0xf366
movsd 0xd34(%rip), %xmm0      # 0x10050
divsd (%rdx,%rcx,8), %xmm0
sarq $0x3, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movapd 0xf68(%rip), %xmm1      # 0x102a0
movsd 0xf90(%rip), %xmm2      # 0x102d0
movsd (%rdx,%r9,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
ucomisd %xmm4, %xmm2
jae 0xf35e
mulsd %xmm0, %xmm3
movsd %xmm3, (%rdx,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0xf340
movq 0x8(%rdi), %r8
subq %rax, %r8
je 0xf3ff
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 0xf12(%rip), %xmm1      # 0x102b0
cmpq %rsi, %r8
je 0xf3f7
leaq (%r8,%r8,2), %r10
movq (%rax,%r10,8), %r9
movsd (%r9,%rcx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0xf3b9
jnp 0xf3f7
leaq (%rax,%r10,8), %r10
movq 0x8(%r10), %r10
subq %r9, %r10
je 0xf3f7
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 0xf3d9
incq %r8
cmpq %rdi, %r8
jne 0xf39e
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf43b
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 0xf41e
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4ae4
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
decq %rax
je 0xf567
leaq 0x8(%rsp), %r14
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 0xf50a
callq 0x21c0
cmpl $-0x1, %ebp
je 0xf571
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf441
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0xf2f9
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x4ae4
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
decq %rax
jne 0xf4ff
testq %rdi, %rdi
je 0xf571
callq 0x21c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x109b(%rip), %xmm0     # 0x106c0
xorl %edi, %edi
xorpd %xmm1, %xmm1
movapd 0xc6d(%rip), %xmm2      # 0x102a0
movsd (%rsi,%rdi,8), %xmm3
ucomisd %xmm1, %xmm3
jae 0xf65a
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 0xf633
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf57a
cmpl $-0x1, %eax
je 0xf69a
movl %eax, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf5fe
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xf2f9
movq %rbx, %rdi
callq 0xf57a
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0xf675
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf663
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorl %esi, %esi
ucomisd (%rax,%rdx,8), %xmm0
seta %r8b
orb %r8b, %sil
incq %rdx
cmpq %rdx, %rcx
jne 0xf6c3
testb $0x1, %sil
je 0xf663
jmp 0xf4cc
// File: /workspace/github_cpp_makefile_star2_O3/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, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %r9, %rdi
callq 0x30c0
movq %rax, %r13
callq 0x5655
movsd %xmm0, 0x20(%rsp)
movl %ebx, %r14d
movl %ebx, 0x1c(%rsp)
testl %ebx, %ebx
jle 0x396c
leaq 0x8(%r15), %rbx
xorl %ebp, %ebp
movq -0x8(%rbx), %rdi
movl (%rbx), %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
callq *%r12
movq 0x60(%rsp), %rcx
movq (%rcx,%rbp,8), %rcx
cmpq %rax, %rcx
jne 0x39d3
incq %rbp
addq $0x10, %rbx
cmpq %rbp, %r14
jne 0x3941
cmpl $0x0, 0x4(%rsp)
jle 0x39c3
shlq $0x3, %r14
xorl %eax, %eax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x39b6
xorl %ebx, %ebx
movq 0x60(%rsp), %rax
movq (%rax,%rbx), %rbp
movq (%r15,%rbx,2), %rdi
movl 0x8(%r15,%rbx,2), %esi
movq 0x10(%rsp), %rdx
movl %r13d, %ecx
callq *%r12
cmpq %rax, %rbp
jne 0x3a50
addq $0x8, %rbx
cmpq %rbx, %r14
jne 0x3987
movq 0x8(%rsp), %rax
incl %eax
cmpl 0x4(%rsp), %eax
jne 0x3979
callq 0x5655
subsd 0x20(%rsp), %xmm0
jmp 0x3a54
movq 0x6606(%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 0x44e4
movq %rax, %r13
subq $0x8, %rsp
leaq 0x3745(%rip), %rsi      # 0x716a
movq %r15, %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%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
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %esi, %esi
jle 0x4509
movq %rdi, %rbx
movl %esi, %ebp
cmpb $0x0, -0x1(%rbx,%rbp)
jne 0x4521
leal -0x1(%rsi), %eax
cmpl $0x1, %esi
movl %eax, %esi
jg 0x44f6
movl $0x4, %edi
callq 0x3260
movb $0x22, (%rax)
movq %rax, %r15
incq %r15
jmp 0x45ee
movl $0x3, %r14d
xorl %r15d, %r15d
leaq 0x2c7f(%rip), %r12      # 0x71b0
movzbl (%rbx,%r15), %ecx
movl $0x2, %eax
cmpb $0x0, (%rcx,%r12)
jne 0x455e
movsbq %cl, %r13
callq 0x31d0
movq (%rax), %rax
xorl %ecx, %ecx
cmpw $0x0, (%rax,%r13,2)
setns %cl
leal (%rcx,%rcx,2), %eax
incl %eax
addl %eax, %r14d
incq %r15
cmpq %r15, %rbp
jne 0x4531
incl %r14d
movq %r14, %rdi
callq 0x3260
movq %rax, %r15
movb $0x22, (%rax)
movq %rax, (%rsp)
incq %r15
xorl %r14d, %r14d
movzbl (%rbx,%r14), %r13d
movb (%r13,%r12), %al
testb %al, %al
je 0x45a0
movb $0x5c, (%r15)
movb %al, 0x1(%r15)
addq $0x2, %r15
jmp 0x45e2
cmpb $0x20, %r13b
je 0x45dc
movsbq %r13b, %r12
callq 0x31d0
movq (%rax), %rax
cmpw $0x0, (%rax,%r12,2)
leaq 0x2bf1(%rip), %r12      # 0x71b0
js 0x45dc
movq %r15, %rdi
leaq 0x2bd3(%rip), %rsi      # 0x719e
movl %r13d, %edx
xorl %eax, %eax
callq 0x3060
cltq
addq %rax, %r15
jmp 0x45e2
movb %r13b, (%r15)
incq %r15
incq %r14
cmpq %r14, %rbp
jne 0x4584
movq (%rsp), %rax
movw $0x22, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c8484(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490910
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c8499(%rip), %rsi    # 0x5ce0ca
callq 0x4a24f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x405c5d
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x405c67
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490910
movq %rax, %r14
leaq 0x1c8416(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490910
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %r14, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x405ce0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x405cfb
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x410332
movq %rbx, %rdi
callq 0x410226
movb $0x1, 0x228(%rbx)
movq %rbx, %rdi
callq 0x4101de
movl $0xb8, %edi
callq 0x427e10
movq %rax, %r14
movq $0x652c08, %rsi         # imm = 0x652C08
movq %rax, %rdi
callq 0x416860
addq $0xc0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e11a
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 0x426e30
jmp 0x405d9a
movq %rax, %rbx
jmp 0x405d90
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x405d90
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x40512c
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x241d30(%rip), %rax    # 0x647d80
movq %rax, (%rdi)
movq 0x230(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x47e(%rip), %rdx      # 0x405be8
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
leaq 0x38(%rbx), %rdi
movq $0x6525f0, %rsi         # imm = 0x6525F0
leaq 0xd0(%rsp), %rdx
callq 0x40dfa4
leaq 0xd0(%rsp), %rdi
callq 0x410332
leaq -0x305(%rip), %rdx      # 0x405da2
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
leaq 0xc0(%rbx), %r14
movq $0x652c60, %rsi         # imm = 0x652C60
leaq 0x78(%rsp), %rdx
movq %r14, %rdi
callq 0x40dfa4
leaq 0x78(%rsp), %rdi
callq 0x410332
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c7fa5(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490910
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x1c7fa8(%rip), %rsi    # 0x5ce0b8
callq 0x4a24f0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x40613c
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x406147
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490910
movq %rax, %r15
leaq 0x1c7f36(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490910
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %r15, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4061bf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4061da
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x20(%rsp), %rdi
callq 0x410332
movq %r14, %rdi
callq 0x416bbe
movq %rbx, %rdi
callq 0x411b6e
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x405453
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x427e10
movq %rax, %rbx
movq $0x6525f0, %rsi         # imm = 0x6525F0
movq %rax, %rdi
callq 0x406584
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40e11a
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 0x426e30
movq %r14, %rdi
callq 0x4d10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x410226
movq %rbx, %rdi
callq 0x4101de
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c7e06(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490910
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x1c7e33(%rip), %rsi    # 0x5ce0e2
callq 0x4a24f0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4062da
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x4062e4
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490910
movq %rax, %rbx
leaq 0x1c7d99(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490910
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %rbx, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40635c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406377
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x20(%rsp), %rdi
callq 0x410332
callq 0x404f28
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x4063ac
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4063ac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x20(%rsp), %rdi
callq 0x40512c
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x41026c
leaq 0x2417c3(%rip), %rax    # 0x647e18
movq %rax, (%rbx)
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x407340
leaq 0x130(%rbx), %r15
movq %r15, %rdi
callq 0x4107c4
movq %rbp, 0x38(%rbx)
movq %r15, %rdi
movq %r13, %rsi
callq 0x410b04
movq %r12, 0x188(%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x410a2c
movq 0x188(%rbx), %rdx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4078f8
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4066c1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x426e30
movq %rsp, %rdi
callq 0x410332
leaq 0xd8(%rbx), %rdi
leaq 0x24c029(%rip), %rsi    # 0x652700
callq 0x410b04
movq 0x38(%rbx), %r12
leaq 0xb0(%rsp), %rdi
movl $0x29, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652b58, %rsi         # imm = 0x652B58
leaq 0xb0(%rsp), %rdx
movq %r12, %rdi
callq 0x40ded4
leaq 0xb0(%rsp), %rdi
callq 0x410332
movq 0x38(%rbx), %r12
leaq 0x58(%rsp), %rdi
movl $0x31, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652bb0, %rsi         # imm = 0x652BB0
leaq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x40ded4
leaq 0x58(%rsp), %rdi
callq 0x410332
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 0x40677e
movq %rax, %r12
leaq 0xb0(%rsp), %rdi
callq 0x410332
jmp 0x40679f
movq %rax, %r12
movq %rsp, %rdi
callq 0x40512c
jmp 0x40679f
movq %rax, %r12
jmp 0x4067a7
movq %rax, %r12
jmp 0x4067af
movq %rax, %r12
movq %r15, %rdi
callq 0x40512c
movq %r14, %rdi
callq 0x4073a8
movq %rbx, %rdi
callq 0x410332
movq %r12, %rdi
callq 0x4d10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x241644(%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 0x40bcd8
movq $0x652b58, %rsi         # imm = 0x652B58
leaq 0x60(%rsp), %rdx
movq %r14, %rdi
callq 0x40dfa4
leaq 0x60(%rsp), %rdi
callq 0x410332
movq 0x38(%rbx), %r14
leaq 0x8(%rsp), %rdi
movl $0x31, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652bb0, %rsi         # imm = 0x652BB0
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x40dfa4
leaq 0x8(%rsp), %rdi
callq 0x410332
movq 0x168(%rbx), %rdi
leaq 0x178(%rbx), %rax
cmpq %rax, %rdi
je 0x406867
movq (%rax), %rsi
incq %rsi
callq 0x426e30
leaq 0x130(%rbx), %rdi
callq 0x410332
leaq 0x40(%rbx), %rdi
callq 0x4073a8
movq %rbx, %rdi
callq 0x410332
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x405453
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24be5d(%rip), %rdx    # 0x652740
jne 0x406979
movq %rdi, %r14
testq %rdx, %rdx
je 0x406908
movq 0x24be40(%rip), %rsi    # 0x652738
movq 0x90(%rbx), %rdi
callq 0x401090
testl %eax, %eax
jne 0x406979
leaq 0x24bdf1(%rip), %rsi    # 0x652700
movq %rsp, %r15
movq %r15, %rdi
callq 0x410a2c
movq $0x652b00, %rsi         # imm = 0x652B00
leaq 0x58(%rsp), %rdi
movq %r15, %rdx
callq 0x416802
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406949
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x426e30
movq %rsp, %rdi
callq 0x410332
movq %r14, %rdi
callq 0x410226
movq 0x38(%r14), %rdi
leaq 0x58(%rsp), %rsi
callq 0x40e11a
movq %r14, %rdi
callq 0x4101de
leaq 0x58(%rsp), %rdi
callq 0x41697a
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 0x40512c
jmp 0x4069a8
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x41697a
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24bb0c(%rip), %rsi    # 0x652700
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x410a2c
leaq 0x40(%rbx), %rcx
movq $0x652aa8, %rsi         # imm = 0x652AA8
leaq 0x60(%rsp), %rdi
movq %r14, %rdx
callq 0x4166b0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406c34
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x8(%rsp), %rdi
callq 0x410332
movq %rbx, %rdi
callq 0x410226
movq 0x38(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0x40e11a
movq %rbx, %rdi
callq 0x4101de
leaq 0x60(%rsp), %rdi
callq 0x41697a
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40512c
jmp 0x406c8d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x41697a
movq %rbx, %rdi
callq 0x4d10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40c31c
movq %rax, %rbx
leaq 0x60(%rsp), %r12
movl $0x41, %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652768, %rsi         # imm = 0x652768
movq %rbx, %rdi
movq %r12, %rdx
callq 0x40dfa4
leaq 0x60(%rsp), %rdi
callq 0x410332
leaq 0x8(%rsp), %r12
movl $0x39, %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x6527c0, %rsi         # imm = 0x6527C0
movq %rbx, %rdi
movq %r12, %rdx
callq 0x40dfa4
leaq 0x8(%rsp), %rdi
callq 0x410332
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq $0x652818, %rsi         # imm = 0x652818
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
callq 0x4090a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e11a
leaq 0xb8(%rsp), %rdi
callq 0x408fea
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x408fea
jmp 0x406d90
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x406d8b
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x410332
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40bcd8
movq $0x652870, %rsi         # imm = 0x652870
movq %r14, %rdi
movq %r15, %rdx
callq 0x40ded4
leaq 0x8(%rsp), %rdi
callq 0x410332
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 0x410332
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x410226
leaq 0x38(%r15), %rdi
movq %r14, %rsi
callq 0x410b04
movq %rbx, 0x90(%r15)
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4101de
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40fc0c
leaq 0x24056b(%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 0x40bcd8
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40ded4
leaq 0x8(%rsp), %rdi
callq 0x410332
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x410332
jmp 0x407a06
movq %rax, %r14
movq %rbx, %rdi
callq 0x40fc3a
movq %r14, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2404e3(%rip), %rax    # 0x647f08
movq %rax, (%rdi)
leaq 0x8(%rsp), %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40dfa4
leaq 0x8(%rsp), %rdi
callq 0x410332
movq 0x90(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x40fc3a
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x405453
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x410226
movq 0x90(%rbx), %r15
movq %rbx, %rdi
callq 0x4101de
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 0x407fbc
movq %r15, %rdi
movq %r14, %rsi
callq 0x412e0e
cmpq $-0x1, %rax
jne 0x407e2d
movq $0x653b20, %rdi         # imm = 0x653B20
leaq 0x1c62f5(%rip), %rsi    # 0x5ce153
movl $0x7, %edx
callq 0x490910
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c64db(%rip), %rsi    # 0x5ce35d
callq 0x4a24f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x407eae
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x407eb8
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq $0x653b20, %rbx         # imm = 0x653B20
movq %rbx, %rdi
callq 0x490910
movq %rax, %r14
leaq 0x1c61c2(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490910
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %r14, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x407f34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x407f4f
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x410332
leaq 0x1c61f3(%rip), %rsi    # 0x5ce153
movl $0x7, %edx
movq %rbx, %rdi
callq 0x490910
leaq 0x1c6407(%rip), %rsi    # 0x5ce37b
movl $0xa, %edx
movq %rbx, %rdi
callq 0x490910
leaq 0x1c6123(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rbx, %rdi
callq 0x490910
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %rbx, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x407fe8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x407fe8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x40512c
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x410226
cmpb $0x0, 0x98(%rbx)
je 0x408032
movq %rbx, %rdi
addq $0xb8, %rsp
popq %rbx
popq %r14
jmp 0x4101de
movq 0x90(%rbx), %rdi
callq 0x41217a
movb $0x1, 0x98(%rbx)
movq %rbx, %rdi
callq 0x4101de
movq $0x652c60, %rsi         # imm = 0x652C60
movq %rsp, %r14
movq %r14, %rdi
callq 0x416860
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e11a
movq %rsp, %rdi
callq 0x41697a
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41697a
movq %rbx, %rdi
callq 0x4d10c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40fc0c
leaq 0x23ed1c(%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 0x41026c
leaq 0x23ed77(%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 0x40bcd8
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x40ded4
leaq 0x58(%rsp), %rdi
callq 0x410332
movq %rsp, %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652818, %rsi         # imm = 0x652818
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x40ded4
movq %rsp, %rdi
callq 0x410332
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rsp, %rdi
jmp 0x4093e4
movq %rax, %r15
leaq 0x58(%rsp), %rdi
callq 0x410332
jmp 0x40940b
movq %rax, %r15
movq (%r13), %rdi
testq %rdi, %rdi
je 0x409413
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0x426e30
jmp 0x409413
movq %rax, %r15
movq %r14, %rdi
callq 0x40a810
movq %rbx, %rdi
callq 0x40fc3a
movq %r15, %rdi
callq 0x4d10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23ebee(%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 0x40bcd8
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0xd8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40dfa4
leaq 0xd8(%rsp), %rdi
callq 0x410332
leaq 0x80(%rsp), %rdi
movl $0x39, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq $0x652818, %rsi         # imm = 0x652818
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
callq 0x40dfa4
leaq 0x80(%rsp), %rdi
callq 0x410332
movq $0x653c40, %rdi         # imm = 0x653C40
leaq 0x1c4bbe(%rip), %rsi    # 0x5ce091
movl $0x4, %edx
callq 0x490910
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c5044(%rip), %rsi    # 0x5ce53b
callq 0x4a24f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x409523
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x40952d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq $0x653c40, %rdi         # imm = 0x653C40
callq 0x490910
movq %rax, %r14
leaq 0x1c4b50(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490910
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %r14, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4095a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4095c1
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x410332
leaq 0x98(%rbx), %rdi
callq 0x410332
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x4095f2
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0x426e30
movq %rbx, %rdi
callq 0x40fc3a
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x405453
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/warp10server/src/Network/WebListener.cpp
// Function: Warp10::Network::WebListener::listen()
void WebListener::listen()
{
	bool ret = _socket->listen();

	if(ret == false) {
		error(className()+"::listen: Can not etablish connection.");
		u::Network::Event close(
			u::Network::Event::CLOSE
		);
		dispatchEvent(&close);
		return;
	}

	// start incoming connections
	Callback cb(this, cb_cast(&WebListener::listenSocket));
	ThreadSystem::create(&cb);

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0x412802
testb %al, %al
je 0x40968e
leaq 0x28(%rsp), %r14
movl $0x41, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40bcd8
movq %r14, %rdi
callq 0x414564
leaq 0x28(%rsp), %rdi
callq 0x410332
jmp 0x4097bd
movq $0x653b20, %rdi         # imm = 0x653B20
leaq 0x1c4ab7(%rip), %rsi    # 0x5ce153
movl $0x7, %edx
callq 0x490910
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x1c4eae(%rip), %rsi    # 0x5ce56e
callq 0x4a24f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4096ec
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x4096f6
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq $0x653b20, %rdi         # imm = 0x653B20
callq 0x490910
movq %rax, %r14
leaq 0x1c4987(%rip), %rsi    # 0x5ce0ab
movl $0x4, %edx
movq %rax, %rdi
callq 0x490910
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x471a60
movsbl %al, %esi
movq %r14, %rdi
callq 0x490410
movq %rax, %rdi
callq 0x48f9e0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x40976f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40978a
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x410332
movq $0x652c08, %rsi         # imm = 0x652C08
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x416860
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e11a
leaq 0x28(%rsp), %rdi
callq 0x41697a
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41697a
jmp 0x409811
movq %rax, %rbx
jmp 0x409807
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x410332
jmp 0x409811
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x409807
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x426e30
leaq 0x28(%rsp), %rdi
callq 0x40512c
movq %rbx, %rdi
callq 0x4d10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/warp10server/src/Network/WebListener.cpp
// Function: Warp10::Network::WebListener::onClose(u::Object*)
void WebListener::onClose(Object* arg)
{
	bool sendWillClose = false;
	arg->destroy();
	lock();
	if(_isClosed == false) {

		_socket->close();
		
		int64 i = 0, l = _connections.length();
		for(; i < l; i++)
		{
			u::Network::Event close(u::Network::Event::CLOSE);
			IConnection* connection = _connections[i];
			connection->dispatchEvent(&close);
		}

		sendWillClose = true;
	}
	_isClosed = true;
	unlock();

	checkClosed();

	if(sendWillClose == true) {
		WebEvent willClose(WebEvent::WILL_CLOSE);
		dispatchEvent(&willClose);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x410226
cmpb $0x0, 0xe8(%rbx)
je 0x40986e
movb $0x1, 0xe8(%rbx)
movq %rbx, %rdi
callq 0x4101de
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x28(%rax)
movq 0x90(%rbx), %rdi
callq 0x41217a
movq 0xd8(%rbx), %r13
subq 0xd0(%rbx), %r13
sarq $0x3, %r13
testq %r13, %r13
jle 0x4098df
xorl %r14d, %r14d
movq $0x652c08, %r15         # imm = 0x652C08
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x416860
movq 0xd0(%rbx), %rax
movq 0xd8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x40992d
movq (%rax,%r14,8), %rdi
movq %r12, %rsi
callq 0x40e11a
movq %r12, %rdi
callq 0x41697a
incq %r14
cmpq %r14, %r13
jne 0x40989e
movb $0x1, 0xe8(%rbx)
movq %rbx, %rdi
callq 0x4101de
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq $0x6527c0, %rsi         # imm = 0x6527C0
movq %rsp, %r14
movq %r14, %rdi
callq 0x4090a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40e11a
movq %rsp, %rdi
callq 0x408fea
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1c4a94(%rip), %rdi    # 0x5ce3c8
movq %r14, %rsi
xorl %eax, %eax
callq 0x471570
movq %rax, %rbx
movq %rsp, %rdi
callq 0x408fea
jmp 0x409958
jmp 0x40994d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41697a
movq %rbx, %rdi
callq 0x4d10c0