LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xab5a(%rip), %rsi      # 0x1b089
callq 0x20a0
cmpl $0x0, %eax
jne 0x10559
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2040
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
jmp 0x105e5
movq 0x8(%rsp), %rdi
leaq 0xab1f(%rip), %rsi      # 0x1b084
callq 0x20a0
cmpl $0x0, %eax
jne 0x1058c
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2040
movq 0x10(%rsp), %rax
movl $0x1, 0x20(%rax)
jmp 0x105e3
movq 0x8(%rsp), %rdi
leaq 0xaaf0(%rip), %rsi      # 0x1b088
callq 0x20a0
cmpl $0x0, %eax
jne 0x105bf
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2040
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
jmp 0x105e1
movq 0x13a12(%rip), %rdi     # 0x23fd8
leaq 0xad13(%rip), %rsi      # 0x1b2e0
callq 0x21f0
movq %rax, %rdi
movq 0x139ec(%rip), %rsi     # 0x23fc8
callq 0x2210
jmp 0x105e3
jmp 0x105e5
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mororo18[P]simplex-method/src/simplex.cpp
// Function: tableau_print(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
void tableau_print(const Tableau & tableau){
    for(int i = 0; i < tableau.size(); i++){
        for(int j = 0; j < tableau[i].size(); j++){
            std::cout << tableau[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10760
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a097
movl $0x0, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x1a870
movq %rax, %rdi
callq 0x6420
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a074
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x1a870
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0x10a10
movsd (%rax), %xmm0
movq 0x9f85(%rip), %rdi      # 0x23fd8
callq 0x2370
movq %rax, %rdi
leaq 0x1398(%rip), %rsi      # 0x1b3fa
callq 0x21f0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x19ffe
movq 0x9f5d(%rip), %rdi      # 0x23fd8
movq 0x9f46(%rip), %rsi      # 0x23fc8
callq 0x2210
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x19fd1
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x109f0
movsd 0xe1b(%rip), %xmm0      # 0x1b050
divsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movsd 0x20(%rsp), %xmm0
callq 0x1a0a0
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a329
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1a2c2
jp 0x1a2c2
jmp 0x1a2cc
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jne 0x1a2ce
jmp 0x1a319
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x10780
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x10780
movq (%rsp), %rdi
movq %rax, %rsi
movsd 0x10(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x1a160
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1a264
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x6420
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1a3c9
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a3ba
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1a3bc
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1a357
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mororo18[P]simplex-method/src/simplex.cpp
// Function: simplex_pivot_row_identify(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int)
int simplex_pivot_row_identify(Tableau & tableau, int pivot_column){
    //std::vector<double
    double lim;
    double lim_min  = 9999999;
    int row_i;
    bool first = true;
    int k = tableau[0].size() - 1;      //restrictions column
    for(int i = 1; i < tableau.size(); i++){
        double co_ij = tableau[i][pivot_column];
        if(co_ij <= DBL_EPSILON) //less or eq to 0
            continue;
        
        lim = tableau[i][k] / co_ij;
        if(lim < lim_min ){
            lim_min = lim;
            row_i = i;
        }

    }

    return row_i;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movsd 0x12ab(%rip), %xmm0     # 0x1b6a0
movsd %xmm0, 0x28(%rsp)
movb $0x1, 0x23(%rsp)
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
subq $0x1, %rax
movl %eax, 0x1c(%rsp)
movl $0x1, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a4e7
movq 0x40(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0xe17(%rip), %xmm0      # 0x1b290
ucomisd 0x10(%rsp), %xmm0
jb 0x1a483
jmp 0x1a4d7
movq 0x40(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a4d5
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1a4d7
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1a426
movl 0x24(%rsp), %eax
addq $0x48, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x5b80
leaq 0x10(%rsp), %rdi
callq 0x1a330
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6bc0
movl 0x8(%rsp), %eax
movl %eax, 0x28(%rsp)
cmpl $-0x1, 0x28(%rsp)
jne 0x1a545
jmp 0x1a56b
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x1a3e0
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x1a200
jmp 0x1a501
addq $0x38, %rsp
retq
// File: 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 dual_simplex_pivot_row_identify(Tableau & tableau){
    double min = 0;
    int row_i = -1;
    int k = tableau[0].size() - 1;      //restrictions column
    for(int row = 1; row < tableau.size(); row++){
        double co_ij = tableau[row][k];

        if(co_ij >= 0) // g_eq then 0
            continue;

        if(co_ij < min){
            min = co_ij;
            row_i = row;
        }
            
    }

    return row_i;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
subq $0x1, %rax
movl %eax, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x10760
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a640
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x20(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a608
jmp 0x1a630
movsd 0x10(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a62e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1a630
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1a5b0
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movsd 0x103b(%rip), %xmm0     # 0x1b6a0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1a75c
movq 0x40(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a6e7
jmp 0x1a74c
movq 0x40(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x10780
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x109f0
movsd (%rax), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x11af0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a74a
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1a74c
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1a67b
movl 0x24(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1a570
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x1a790
jmp 0x1a7b6
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1a650
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x1a200
jmp 0x1a779
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movl $0x0, 0x8(%rsp)
movslq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
callq 0x6420
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1a83d
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
movq %rax, %rdi
movslq 0x8(%rsp), %rsi
callq 0x109f0
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x1a82e
movb $0x1, 0xf(%rsp)
jmp 0x1a830
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1a7d6
testb $0x1, 0xf(%rsp)
je 0x1a850
movq 0x10(%rsp), %rdi
callq 0x1a4f0
jmp 0x1a85a
movq 0x10(%rsp), %rdi
callq 0x1a770
addq $0x18, %rsp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq $0x668c60, %rdi         # imm = 0x668C60
leaq 0x1d3e9c(%rip), %rsi    # 0x5db091
callq 0x49dd60
movq %rax, -0xa8(%rbp)
movb $0x0, -0x89(%rbp)
movb $0x0, -0x9e(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x407217
jmp 0x40724d
movq -0xb0(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
movb $0x1, -0x89(%rbp)
leaq -0x50(%rbp), %rsi
leaq 0x1d3ef9(%rip), %rdx    # 0x5db139
leaq -0x30(%rbp), %rdi
callq 0x405d00
jmp 0x40724b
jmp 0x407282
leaq -0x9d(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x435b90
movq -0xb8(%rbp), %rdx
movb $0x1, -0x9e(%rbp)
leaq 0x1f972d(%rip), %rsi    # 0x6009a2
leaq -0x30(%rbp), %rdi
callq 0x407e60
jmp 0x407280
jmp 0x407282
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4b05e0
movq %rax, -0xc0(%rbp)
jmp 0x40729b
movq -0xc0(%rbp), %rdi
leaq 0x1d3e27(%rip), %rsi    # 0x5db0d0
callq 0x49dd60
movq %rax, -0xc8(%rbp)
jmp 0x4072b7
movq -0xc8(%rbp), %rdi
movq $0x49d640, %rsi         # imm = 0x49D640
callq 0x49c850
jmp 0x4072cc
leaq -0x30(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0x9e(%rbp)
jne 0x4072e0
jmp 0x4072ec
leaq -0x9d(%rbp), %rdi
callq 0x435bb0
testb $0x1, -0x89(%rbp)
jne 0x4072f7
jmp 0x407303
leaq -0x88(%rbp), %rdi
callq 0x405650
movq -0xb0(%rbp), %rdi
callq 0x417410
movq -0xb0(%rbp), %rdi
movb $0x1, 0x228(%rdi)
callq 0x417380
movq -0xb0(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0xd8(%rbp)
movl $0xb8, %edi
callq 0x434cd0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq $0x667c28, %rsi         # imm = 0x667C28
callq 0x41fd30
jmp 0x40735b
movq -0xd0(%rbp), %rsi
movq -0xd8(%rbp), %rdi
callq 0x412820
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x4073db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x4073c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0x9e(%rbp)
jne 0x4073cd
jmp 0x4073d9
leaq -0x9d(%rbp), %rdi
callq 0x435bb0
jmp 0x4073db
testb $0x1, -0x89(%rbp)
jne 0x4073e6
jmp 0x4073f2
leaq -0x88(%rbp), %rdi
callq 0x405650
jmp 0x407417
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
movl $0xb8, %esi
callq 0x433cf0
movq -0x98(%rbp), %rdi
callq 0x4deb40
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq 0x2554bf(%rip), %rcx    # 0x65cce0
movq %rcx, (%rax)
movq 0x230(%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x407835
movq -0x160(%rbp), %rsi
movq %rsi, %rax
addq $0x38, %rax
movq %rax, -0x168(%rbp)
leaq -0x691(%rip), %rax      # 0x4071c0
movq %rax, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rdi
callq 0x410a10
jmp 0x407875
movq -0x168(%rbp), %rdi
movq $0x667610, %rsi         # imm = 0x667610
leaq -0x60(%rbp), %rdx
callq 0x4126f0
jmp 0x40788e
leaq -0x60(%rbp), %rdi
callq 0x407e40
movq -0x160(%rbp), %rsi
movq %rsi, %rax
addq $0xc0, %rax
movq %rax, -0x170(%rbp)
leaq -0x485(%rip), %rax      # 0x407430
movq %rax, -0xd8(%rbp)
movq $0x0, -0xd0(%rbp)
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0xc8(%rbp), %rdi
callq 0x410a10
jmp 0x4078e8
movq -0x170(%rbp), %rdi
movq $0x667c80, %rsi         # imm = 0x667C80
leaq -0xc8(%rbp), %rdx
callq 0x4126f0
jmp 0x407904
leaq -0xc8(%rbp), %rdi
callq 0x407e40
movq $0x668c60, %rdi         # imm = 0x668C60
leaq 0x1d3773(%rip), %rsi    # 0x5db091
callq 0x49dd60
movq %rax, -0x178(%rbp)
jmp 0x40792c
movb $0x0, -0x151(%rbp)
movb $0x0, -0x153(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x407942
jmp 0x407980
movq -0x160(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x150(%rbp), %rdi
callq *%rax
jmp 0x40795b
movb $0x1, -0x151(%rbp)
leaq -0x118(%rbp), %rsi
leaq 0x1d378f(%rip), %rdx    # 0x5db0ff
leaq -0xf8(%rbp), %rdi
callq 0x405d00
jmp 0x40797e
jmp 0x4079b8
leaq -0x152(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x435b90
movq -0x180(%rbp), %rdx
movb $0x1, -0x153(%rbp)
leaq 0x1f8ffa(%rip), %rsi    # 0x6009a2
leaq -0xf8(%rbp), %rdi
callq 0x407e60
jmp 0x4079b6
jmp 0x4079b8
movq -0x178(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x4b05e0
movq %rax, -0x188(%rbp)
jmp 0x4079d4
movq -0x188(%rbp), %rdi
leaq 0x1d36ee(%rip), %rsi    # 0x5db0d0
callq 0x49dd60
movq %rax, -0x190(%rbp)
jmp 0x4079f0
movq -0x190(%rbp), %rdi
movq $0x49d640, %rsi         # imm = 0x49D640
callq 0x49c850
jmp 0x407a05
leaq -0xf8(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0x153(%rbp)
jne 0x407a1c
jmp 0x407a28
leaq -0x152(%rbp), %rdi
callq 0x435bb0
testb $0x1, -0x151(%rbp)
jne 0x407a33
jmp 0x407a3f
leaq -0x150(%rbp), %rdi
callq 0x405650
movq -0x160(%rbp), %rdi
addq $0xc0, %rdi
callq 0x420220
movq -0x160(%rbp), %rdi
callq 0x41a1d0
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rdi
callq 0x405b40
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movl $0x50, %edi
callq 0x434cd0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq $0x667610, %rsi         # imm = 0x667610
callq 0x4081a0
jmp 0x407aaa
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x412820
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x50, %esi
callq 0x433cf0
movq -0x10(%rbp), %rdi
callq 0x4deb40
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x417410
movq -0xa8(%rbp), %rdi
callq 0x417380
movq $0x668c60, %rdi         # imm = 0x668C60
leaq 0x1d3568(%rip), %rsi    # 0x5db091
callq 0x49dd60
movq %rax, -0xa0(%rbp)
movb $0x0, -0x81(%rbp)
movb $0x0, -0x96(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x407b4b
jmp 0x407b7e
movq -0xa8(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x80(%rbp), %rdi
callq *%rax
movb $0x1, -0x81(%rbp)
leaq -0x48(%rbp), %rsi
leaq 0x1d3601(%rip), %rdx    # 0x5db172
leaq -0x28(%rbp), %rdi
callq 0x405d00
jmp 0x407b7c
jmp 0x407bb3
leaq -0x95(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x435b90
movq -0xb0(%rbp), %rdx
movb $0x1, -0x96(%rbp)
leaq 0x1f8dfc(%rip), %rsi    # 0x6009a2
leaq -0x28(%rbp), %rdi
callq 0x407e60
jmp 0x407bb1
jmp 0x407bb3
movq -0xa0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b05e0
movq %rax, -0xb8(%rbp)
jmp 0x407bcc
movq -0xb8(%rbp), %rdi
leaq 0x1d34f6(%rip), %rsi    # 0x5db0d0
callq 0x49dd60
movq %rax, -0xc0(%rbp)
jmp 0x407be8
movq -0xc0(%rbp), %rdi
movq $0x49d640, %rsi         # imm = 0x49D640
callq 0x49c850
jmp 0x407bfd
leaq -0x28(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0x96(%rbp)
jne 0x407c11
jmp 0x407c1d
leaq -0x95(%rbp), %rdi
callq 0x435bb0
testb $0x1, -0x81(%rbp)
jne 0x407c28
jmp 0x407c31
leaq -0x80(%rbp), %rdi
callq 0x405650
callq 0x405360
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x407c9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x407c82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0x96(%rbp)
jne 0x407c8d
jmp 0x407c99
leaq -0x95(%rbp), %rdi
callq 0x435bb0
jmp 0x407c9b
testb $0x1, -0x81(%rbp)
jne 0x407ca6
jmp 0x407caf
leaq -0x80(%rbp), %rdi
callq 0x405650
jmp 0x407cb1
movq -0x90(%rbp), %rdi
callq 0x4deb40
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
leaq 0x2547a7(%rip), %rax    # 0x65cd78
movq %rax, (%rsi)
movq 0x38(%rsi), %rax
movq %rax, -0xe0(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x29, -0x70(%rbp)
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rdi
callq 0x410a10
jmp 0x408607
movq -0xe0(%rbp), %rdi
movq $0x667b78, %rsi         # imm = 0x667B78
leaq -0x60(%rbp), %rdx
callq 0x4126f0
jmp 0x408620
leaq -0x60(%rbp), %rdi
callq 0x407e40
movq -0xe8(%rbp), %rsi
movq 0x38(%rsi), %rax
movq %rax, -0xf0(%rbp)
movq $0x0, -0xd0(%rbp)
movq $0x31, -0xd8(%rbp)
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0xc8(%rbp), %rdi
callq 0x410a10
jmp 0x408672
movq -0xf0(%rbp), %rdi
movq $0x667bd0, %rsi         # imm = 0x667BD0
leaq -0xc8(%rbp), %rdx
callq 0x4126f0
jmp 0x40868e
leaq -0xc8(%rbp), %rdi
callq 0x407e40
movq -0xe8(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x405650
movq -0xe8(%rbp), %rdi
addq $0x40, %rdi
callq 0x409690
movq -0xe8(%rbp), %rdi
callq 0x4175e0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x405b40
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
addq $0x38, %rdi
leaq 0x25ef97(%rip), %rsi    # 0x667720
addq $0x38, %rsi
callq 0x409490
testb $0x1, %al
jne 0x40879b
jmp 0x408860
leaq 0x25ef7e(%rip), %rsi    # 0x667720
leaq -0x128(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x417f20
movq -0x148(%rbp), %rdx
movq $0x667b20, %rsi         # imm = 0x667B20
leaq -0xd0(%rbp), %rdi
callq 0x41fc80
jmp 0x4087d1
leaq -0x128(%rbp), %rdi
callq 0x405650
movq -0x140(%rbp), %rdi
callq 0x417410
jmp 0x4087eb
movq -0x140(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x412820
jmp 0x408804
movq -0x140(%rbp), %rdi
callq 0x417380
jmp 0x408812
leaq -0xd0(%rbp), %rdi
callq 0x41fee0
jmp 0x408860
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x405650
jmp 0x408872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x41fee0
jmp 0x408872
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x130(%rbp), %rdi
callq 0x4deb40
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
leaq 0x25eb2f(%rip), %rsi    # 0x667720
leaq -0x118(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x417f20
movq -0x138(%rbp), %rcx
movq -0x130(%rbp), %rdx
addq $0x40, %rcx
movq $0x667ac8, %rsi         # imm = 0x667AC8
leaq -0xc0(%rbp), %rdi
callq 0x41fa70
jmp 0x408c2b
leaq -0x118(%rbp), %rdi
callq 0x405650
movq -0x138(%rbp), %rdi
callq 0x417410
jmp 0x408c45
movq -0x138(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x412820
jmp 0x408c5e
movq -0x138(%rbp), %rdi
callq 0x417380
jmp 0x408c6c
leaq -0xc0(%rbp), %rdi
callq 0x41fee0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x405650
jmp 0x408cbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x41fee0
movq -0x120(%rbp), %rdi
callq 0x4deb40
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x411090
movq -0x2a8(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movq $0x0, -0x80(%rbp)
movq $0x41, -0x88(%rbp)
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x78(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x410a10
movq -0x2a0(%rbp), %rdi
movq -0x298(%rbp), %rdx
movq $0x667788, %rsi         # imm = 0x667788
callq 0x4126f0
jmp 0x408d64
leaq -0x78(%rbp), %rdi
callq 0x407e40
movq -0x2a8(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movq $0x0, -0xf8(%rbp)
movq $0x39, -0x100(%rbp)
movq -0x100(%rbp), %rdx
movq -0xf8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x2b0(%rbp)
callq 0x410a10
movq -0x2b8(%rbp), %rdi
movq -0x2b0(%rbp), %rdx
movq $0x6677e0, %rsi         # imm = 0x6677E0
callq 0x4126f0
jmp 0x408dd7
leaq -0xf0(%rbp), %rdi
callq 0x407e40
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq $0x667838, %rsi         # imm = 0x667838
leaq -0x290(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
callq 0x40bc10
movq -0x2c0(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x412820
jmp 0x408e1b
leaq -0x290(%rbp), %rdi
callq 0x40bbd0
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x407e40
jmp 0x408e8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x407e40
jmp 0x408e8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x40bbd0
movq -0x90(%rbp), %rdi
callq 0x4deb40
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq $0x0, -0x80(%rbp)
movq $0x49, -0x88(%rbp)
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x410a10
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rdx
movq $0x667890, %rsi         # imm = 0x667890
callq 0x412620
jmp 0x408f25
leaq -0x78(%rbp), %rdi
callq 0x407e40
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x407e40
movq -0x90(%rbp), %rdi
callq 0x4deb40
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x417410
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x4180d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x90(%rdi)
callq 0x417380
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xa0(%rbp)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x80(%rdi)
callq 0x40b3d0
movq -0x90(%rbp), %rsi
leaq 0x253033(%rip), %rax    # 0x65cea8
movq %rax, (%rsi)
movb $0x0, 0x88(%rsi)
movq -0x10(%rbp), %rax
movq %rax, 0x90(%rsi)
movb $0x0, 0x98(%rsi)
movq $0x0, -0x70(%rbp)
movq $0x39, -0x78(%rbp)
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x68(%rbp), %rdi
callq 0x410a10
jmp 0x409eb9
movq -0x90(%rbp), %rdi
movq $0x667c28, %rsi         # imm = 0x667C28
leaq -0x68(%rbp), %rdx
callq 0x412620
jmp 0x409ed2
leaq -0x68(%rbp), %rdi
callq 0x407e40
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x409f0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x407e40
movq -0x90(%rbp), %rdi
callq 0x40b410
movq -0x80(%rbp), %rdi
callq 0x4deb40
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
leaq 0x252f5a(%rip), %rax    # 0x65cea8
movq %rax, (%rsi)
movq $0x0, -0x68(%rbp)
movq $0x39, -0x70(%rbp)
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rdi
callq 0x410a10
jmp 0x409f79
movq -0x78(%rbp), %rdi
movq $0x667c28, %rsi         # imm = 0x667C28
leaq -0x60(%rbp), %rdx
callq 0x4126f0
jmp 0x409f8f
leaq -0x60(%rbp), %rdi
callq 0x407e40
movq -0x78(%rbp), %rax
movq 0x90(%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x409fad
movq -0x78(%rbp), %rdi
callq 0x40b410
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x405b40
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x417410
movq -0xb0(%rbp), %rdi
movq 0x90(%rdi), %rax
movq %rax, -0x18(%rbp)
callq 0x417380
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
callq *0x20(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpq $0x0, %rax
je 0x40a74b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41b950
cmpq $-0x1, %rax
jne 0x40a746
movq $0x668b40, %rdi         # imm = 0x668B40
leaq 0x1d0c9f(%rip), %rsi    # 0x5db220
callq 0x49dd60
movq %rax, -0xb8(%rbp)
movb $0x0, -0x91(%rbp)
movb $0x0, -0xa6(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x40a5a3
jmp 0x40a5d9
movq -0xb0(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
movb $0x1, -0x91(%rbp)
leaq -0x58(%rbp), %rsi
leaq 0x1d104c(%rip), %rdx    # 0x5db618
leaq -0x38(%rbp), %rdi
callq 0x405d00
jmp 0x40a5d7
jmp 0x40a60e
leaq -0xa5(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x435b90
movq -0xc0(%rbp), %rdx
movb $0x1, -0xa6(%rbp)
leaq 0x1f63a1(%rip), %rsi    # 0x6009a2
leaq -0x38(%rbp), %rdi
callq 0x407e60
jmp 0x40a60c
jmp 0x40a60e
movq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4b05e0
movq %rax, -0xc8(%rbp)
jmp 0x40a627
movq -0xc8(%rbp), %rdi
leaq 0x1d0a9b(%rip), %rsi    # 0x5db0d0
callq 0x49dd60
movq %rax, -0xd0(%rbp)
jmp 0x40a643
movq -0xd0(%rbp), %rdi
movq $0x49d640, %rsi         # imm = 0x49D640
callq 0x49c850
jmp 0x40a658
leaq -0x38(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0xa6(%rbp)
jne 0x40a66c
jmp 0x40a678
leaq -0xa5(%rbp), %rdi
callq 0x435bb0
testb $0x1, -0x91(%rbp)
jne 0x40a683
jmp 0x40a68f
leaq -0x90(%rbp), %rdi
callq 0x405650
movq $0x668b40, %rdi         # imm = 0x668B40
leaq 0x1d0b83(%rip), %rsi    # 0x5db220
callq 0x49dd60
movq %rax, %rdi
leaq 0x1d0f8a(%rip), %rsi    # 0x5db636
callq 0x49dd60
movq %rax, %rdi
leaq 0x1d0a15(%rip), %rsi    # 0x5db0d0
callq 0x49dd60
movq %rax, %rdi
movq $0x49d640, %rsi         # imm = 0x49D640
callq 0x49c850
jmp 0x40a74b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x40a72d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x40a714
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0xa6(%rbp)
jne 0x40a71f
jmp 0x40a72b
leaq -0xa5(%rbp), %rdi
callq 0x435bb0
jmp 0x40a72d
testb $0x1, -0x91(%rbp)
jne 0x40a738
jmp 0x40a744
leaq -0x90(%rbp), %rdi
callq 0x405650
jmp 0x40a754
jmp 0x40a548
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x4deb40
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0xe8(%rbp), %rdi
callq 0x417410
movq -0xe8(%rbp), %rax
movb 0x98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x40a7c7
movq -0xe8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x41ab30
jmp 0x40a7d5
movq -0xe8(%rbp), %rdi
callq 0x417380
jmp 0x40a823
movq -0xe8(%rbp), %rdi
movb $0x1, 0x98(%rdi)
callq 0x417380
movq $0x667c80, %rsi         # imm = 0x667C80
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x41fd30
movq -0xe8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x412820
jmp 0x40a817
leaq -0xd0(%rbp), %rdi
callq 0x41fee0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x41fee0
movq -0xd8(%rbp), %rdi
callq 0x4deb40
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x108(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x120(%rbp)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x80(%rdi)
callq 0x40db90
movq -0x108(%rbp), %rdi
leaq 0x25109f(%rip), %rax    # 0x65cff8
movq %rax, (%rdi)
addq $0x98, %rdi
movq %rdi, -0x100(%rbp)
callq 0x40dbd0
jmp 0x40bf71
movq -0x108(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, 0x88(%rsi)
movq -0x18(%rbp), %rax
movq %rax, 0x90(%rsi)
movb $0x0, 0xe8(%rsi)
movb $0x0, 0xe9(%rsi)
movq $0x0, -0x88(%rbp)
movq $0x31, -0x90(%rbp)
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x80(%rbp), %rdi
callq 0x410a10
jmp 0x40bfd0
movq -0x108(%rbp), %rdi
movq $0x667c28, %rsi         # imm = 0x667C28
leaq -0x80(%rbp), %rdx
callq 0x412620
jmp 0x40bfe9
leaq -0x80(%rbp), %rdi
callq 0x407e40
movq -0x108(%rbp), %rsi
movq $0x0, -0xf0(%rbp)
movq $0x39, -0xf8(%rbp)
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0xe8(%rbp), %rdi
callq 0x410a10
jmp 0x40c030
movq -0x108(%rbp), %rdi
movq $0x667838, %rsi         # imm = 0x667838
leaq -0xe8(%rbp), %rdx
callq 0x412620
jmp 0x40c04c
leaq -0xe8(%rbp), %rdi
callq 0x407e40
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x40c0b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x40c0ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x407e40
jmp 0x40c0ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x407e40
movq -0x100(%rbp), %rdi
callq 0x40dc40
movq -0x108(%rbp), %rdi
callq 0x40dc70
movq -0x20(%rbp), %rdi
callq 0x4deb40
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq 0x250f07(%rip), %rcx    # 0x65cff8
movq %rcx, (%rax)
movq 0x90(%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x40c105
movq -0x160(%rbp), %rsi
movq $0x0, -0x68(%rbp)
movq $0x31, -0x70(%rbp)
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rdi
callq 0x410a10
jmp 0x40c134
movq -0x160(%rbp), %rdi
movq $0x667c28, %rsi         # imm = 0x667C28
leaq -0x60(%rbp), %rdx
callq 0x4126f0
jmp 0x40c14d
leaq -0x60(%rbp), %rdi
callq 0x407e40
movq -0x160(%rbp), %rsi
movq $0x0, -0xd0(%rbp)
movq $0x39, -0xd8(%rbp)
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq -0xc8(%rbp), %rdi
callq 0x410a10
jmp 0x40c194
movq -0x160(%rbp), %rdi
movq $0x667838, %rsi         # imm = 0x667838
leaq -0xc8(%rbp), %rdx
callq 0x4126f0
jmp 0x40c1b0
leaq -0xc8(%rbp), %rdi
callq 0x407e40
movq $0x668c60, %rdi         # imm = 0x668C60
leaq 0x1ceec7(%rip), %rsi    # 0x5db091
callq 0x49dd60
movq %rax, -0x168(%rbp)
jmp 0x40c1d8
movb $0x0, -0x151(%rbp)
movb $0x0, -0x153(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x40c1ee
jmp 0x40c22c
movq -0x160(%rbp), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x150(%rbp), %rdi
callq *%rax
jmp 0x40c207
movb $0x1, -0x151(%rbp)
leaq -0x118(%rbp), %rsi
leaq 0x1cf66a(%rip), %rdx    # 0x5db886
leaq -0xf8(%rbp), %rdi
callq 0x405d00
jmp 0x40c22a
jmp 0x40c264
leaq -0x152(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x435b90
movq -0x170(%rbp), %rdx
movb $0x1, -0x153(%rbp)
leaq 0x1f474e(%rip), %rsi    # 0x6009a2
leaq -0xf8(%rbp), %rdi
callq 0x407e60
jmp 0x40c262
jmp 0x40c264
movq -0x168(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x4b05e0
movq %rax, -0x178(%rbp)
jmp 0x40c280
movq -0x178(%rbp), %rdi
leaq 0x1cee42(%rip), %rsi    # 0x5db0d0
callq 0x49dd60
movq %rax, -0x180(%rbp)
jmp 0x40c29c
movq -0x180(%rbp), %rdi
movq $0x49d640, %rsi         # imm = 0x49D640
callq 0x49c850
jmp 0x40c2b1
leaq -0xf8(%rbp), %rdi
callq 0x4adc60
testb $0x1, -0x153(%rbp)
jne 0x40c2c8
jmp 0x40c2d4
leaq -0x152(%rbp), %rdi
callq 0x435bb0
testb $0x1, -0x151(%rbp)
jne 0x40c2df
jmp 0x40c2eb
leaq -0x150(%rbp), %rdi
callq 0x405650
movq -0x160(%rbp), %rdi
addq $0x98, %rdi
callq 0x40dc40
movq -0x160(%rbp), %rdi
callq 0x40dc70
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq %rax, %rdi
callq 0x405b40
nopl (%rax,%rax)