// File: /workspace/github_cpp_makefile_star2_O3/fjamour[P]icentral/src/_bc_mem.cc
// Function: iCentral_iter_mem(std::vector<double, std::allocator<double>>&, component_t&, unsigned int, std::pair<unsigned int, unsigned int>, iter_info_t&)
void iCentral_iter_mem(
        vector<double>& dBC_vec,    // delta BC of vertices
        component_t&    comp,       // component could be BCC, MUC, or just a graph
        node_id_t       s,          // source of the iteration
        edge_t          e,          // inserted edge
        iter_info_t&    iter_info   //TODO to be used later?
        )
{
//    RBFS(dBC_vec, comp, s, iter_info, false, true);
//    partial_BBFS(iter_info, comp, s, e);
//    RBFS(dBC_vec, comp, s, iter_info, true, false);
//    fill(iter_info.sigma_inc_vec.begin(), iter_info.sigma_inc_vec.end(), 0);
//    fill(iter_info.visited_vec.begin(), iter_info.visited_vec.end(), false);
    
    subgraph_t& g = comp.subgraph;
    
    vector<vector<node_id_t> >&  P = iter_info.P;
    vector<int>&                 sigma_vec = iter_info.sigma_vec;
    vector<int>&                 sigma_inc_vec = iter_info.sigma_inc_vec;
    vector<int>&                 dist_map = iter_info.dist_vec;
    vector<bool>&                visited_vec = iter_info.visited_vec;
    //vector<node_id_t>&           S = iter_info.S;
    
    vector<double>&              delta_vec = iter_info.delta_vec;
    
    vector<double>&              new_delta_vec = iter_info.new_delta_vec;
    new_delta_vec = delta_vec;
    
    static vector<vector<node_id_t> >   new_P;
    fill_vec<vector<node_id_t> >(new_P, g.size(), vector<node_id_t>());
    //static vector<vector<node_id_t> >   lost_P;;
    //fill_vec<vector<node_id_t> >(lost_P, g.size(), vector<node_id_t>());
    static vector<int>                  new_sigma_vec = iter_info.new_sigma_vec;
    new_sigma_vec = sigma_vec;
    static vector<stack<node_id_t> >    level_vec;

    queue<node_id_t>             Q;
    node_id_t src, dst;
    if(dist_map[e.first] > dist_map[e.second]) {
        src = e.second;
        dst = e.first;
    } else {
        src = e.first;
        dst = e.second;
    }
    
    //S.clear();
    level_vec.resize(dist_map[dst]+1);
    
    //Compute new path counts and paths
    if(dist_map[dst] != dist_map[src]+1) {
        //lost_P[dst] = P[dst];
        new_P[dst].push_back(src);
        for(int p = 0; p < P[dst].size(); ++p){
            node_id_t parent = P[dst][p];
            new_delta_vec[parent] -= (((double) sigma_vec[parent] / sigma_vec[dst]) * (1 + delta_vec[dst]));
            if(dist_map[parent] == dist_map[src]+1) {
                level_vec[dist_map[parent]].push(parent);
            }
        }
        P[dst].clear();
        //P[dst].push_back(src);
        new_sigma_vec[dst] = new_sigma_vec[src];
    } else {
        new_P[dst].push_back(src);
        //P[dst].push_back(src);
        new_sigma_vec[dst] += new_sigma_vec[src];
    }
        
    Q.push(dst);
    dist_map[dst] = dist_map[src] + 1;
    sigma_inc_vec[dst] = sigma_vec[src];
    visited_vec[dst] = true;

    while (!Q.empty()) {
        node_id_t v = Q.front();
        if(dist_map[v] >= level_vec.size()) {
            stack<node_id_t> qq;
            level_vec.push_back(qq);
            level_vec[dist_map[v]].push(v);
        } else {
            level_vec[dist_map[v]].push(v);
        }
        Q.pop();
        vector<node_id_t> nbr_vec = g.get_nbrs(v);
        for (int nbr_idx = 0; nbr_idx < nbr_vec.size(); ++nbr_idx) {
            node_id_t w = nbr_vec[nbr_idx];
            if (dist_map[w] > (dist_map[v] + 1)) {
                dist_map[w] = dist_map[v] + 1;
                //lost_P[w] = P[w];
                new_P[w].push_back(v);
                for(int p = 0; p < P[w].size(); ++p){
                    node_id_t parent = P[w][p];
                    new_delta_vec[parent] -= (((double) sigma_vec[parent] / sigma_vec[w]) * (1 + delta_vec[w]));
                }
                P[w].clear();
                //P[w].push_back(v);
                new_sigma_vec[w] = 0;
                sigma_inc_vec[w] = sigma_inc_vec[v];
                new_sigma_vec[w] += sigma_inc_vec[w];
                if (!visited_vec[w]) {
                    visited_vec[w] = true;
                    //if(new_sigma_vec[w] != sigma_vec[w])
                        Q.push(w);
                }
            } else if (dist_map[w] == (dist_map[v] + 1)) {
                sigma_inc_vec[w] += sigma_inc_vec[v];
                new_sigma_vec[w] += sigma_inc_vec[v];
                if (find(P[w].begin(), P[w].end(), v) == P[w].end()) {
                    new_P[w].push_back(v);
                }
                if (!visited_vec[w]) {
                    visited_vec[w] = true;
                    //if(new_sigma_vec[w] != sigma_vec[w])
                        Q.push(w);
                }
            }
        }
    }
    
    fill_vec<bool>(visited_vec, g.size(), false);
    
    for(int level = level_vec.size()-1; level >= 0; --level) {
        while(!level_vec[level].empty()) {
            node_id_t w = level_vec[level].top();
            level_vec[level].pop();
            if(!visited_vec[w]) {
                visited_vec[w] = true;
                for (int idx = 0; idx < P[w].size(); ++idx) {
                    node_id_t v = P[w][idx];
                    new_delta_vec[v] -= (((double) sigma_vec[v] / sigma_vec[w]) * (1 + delta_vec[w]));
                    new_delta_vec[v] += (((double) new_sigma_vec[v] / new_sigma_vec[w]) * (1 + new_delta_vec[w]));
                    if(level > 0)
                        level_vec[level-1].push(v);
                }
                for (int idx = 0; idx < new_P[w].size(); ++idx) {
                    node_id_t v = new_P[w][idx];
                    new_delta_vec[v] += (((double) new_sigma_vec[v] / new_sigma_vec[w]) * (1 + new_delta_vec[w]));
                    if(level > 0)
                        level_vec[level-1].push(v);
                }
                //has to update P with new_P for the next edge insertions
                P[w] = new_P[w];
                if (w != s) {
                    dBC_vec[w] -= delta_vec[w]/2.0;
                    dBC_vec[w] += new_delta_vec[w]/2.0;
                }
            }
        }
    }
    
    iter_info.delta_vec = new_delta_vec;
    iter_info.sigma_vec = new_sigma_vec;
    fill(iter_info.sigma_inc_vec.begin(), iter_info.sigma_inc_vec.end(), 0);
    fill(iter_info.visited_vec.begin(), iter_info.visited_vec.end(), false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r8, %r13
movq %rcx, %r12
movl %edx, 0x3c(%rsp)
movq %rsi, %rbx
movq %rdi, 0xe8(%rsp)
leaq 0x48(%r8), %rsi
leaq 0x90(%r8), %r15
movq %r15, %rdi
movq %rsi, 0x20(%rsp)
callq 0x8b1e
movb 0x3732d(%rip), %al      # 0x3f240
testb %al, %al
je 0x8a12
movq %rbx, %rdi
callq 0x2e9da
xorpd %xmm0, %xmm0
leaq 0xf0(%rsp), %rdx
movapd %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x372e6(%rip), %rdi     # 0x3f228
movq %rax, %rsi
callq 0x8c01
movq 0xf0(%rsp), %rdi
testq %rdi, %rdi
je 0x7f67
movq 0x100(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, 0x10(%rsp)
movb 0x372ee(%rip), %al      # 0x3f260
testb %al, %al
movq %r13, 0x18(%rsp)
je 0x8a1c
movq %r12, %rbx
shrq $0x20, %rbx
leaq 0x18(%r13), %rsi
leaq 0x372b7(%rip), %rdi     # 0x3f248
movq %rsi, 0x30(%rsp)
callq 0x8c34
movb 0x372df(%rip), %al      # 0x3f280
testb %al, %al
je 0x8a70
xorpd %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movapd %xmm0, 0x40(%rdi)
movapd %xmm0, 0x30(%rdi)
movapd %xmm0, 0x20(%rdi)
movapd %xmm0, 0x10(%rdi)
movapd %xmm0, (%rdi)
xorl %esi, %esi
callq 0x6ad0
movl %r12d, %eax
movq 0x30(%r13), %rcx
movl (%rcx,%rax,4), %eax
cmpl (%rcx,%rbx,4), %eax
movl %r12d, %eax
cmovgl %ebx, %eax
cmovgl %r12d, %ebx
movl %eax, 0xc(%rsp)
movl %ebx, 0x4(%rsp)
movslq (%rcx,%rbx,4), %rsi
incq %rsi
leaq 0x3726a(%rip), %rdi     # 0x3f268
callq 0x8d60
movq 0x10(%rsp), %rbx
movl 0x4(%rsp), %edx
movq 0x30(%r13), %r8
movl 0xc(%rsp), %eax
movl (%r8,%rax,4), %r9d
incl %r9d
movq 0x37206(%rip), %rcx     # 0x3f228
leaq (%rdx,%rdx,2), %rsi
leaq (%rcx,%rsi,8), %rdi
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rcx
cmpl %r9d, (%r8,%rdx,4)
jne 0x8049
cmpq %rcx, %rsi
je 0x805a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x8064
cmpq %rcx, %rsi
je 0x807e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x8088
leaq 0xc(%rsp), %rdx
callq 0x6f14
movl 0xc(%rsp), %eax
movq 0x371d9(%rip), %rcx     # 0x3f248
movl (%rcx,%rax,4), %eax
movl 0x4(%rsp), %edx
addl %eax, (%rcx,%rdx,4)
jmp 0x819f
leaq 0xc(%rsp), %rdx
callq 0x6f14
movl 0x4(%rsp), %ecx
movq (%r13), %rax
leaq (%rcx,%rcx,2), %rdi
movq (%rax,%rdi,8), %rdx
movq 0x8(%rax,%rdi,8), %rsi
cmpq %rdx, %rsi
je 0x8181
xorl %ebx, %ebx
leaq 0x90(%rsp), %r12
movl (%rdx,%rbx,4), %edx
movl %edx, 0x90(%rsp)
movq 0x18(%r13), %rsi
movq 0x48(%r13), %rdi
xorps %xmm0, %xmm0
cvtsi2sdl (%rsi,%rdx,4), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%rsi,%rcx,4), %xmm1
divsd %xmm1, %xmm0
movsd (%rdi,%rcx,8), %xmm1
addsd 0x27f4d(%rip), %xmm1    # 0x30030
mulsd %xmm0, %xmm1
movq 0x90(%r13), %rcx
movsd (%rcx,%rdx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0x30(%r13), %rsi
movslq (%rsi,%rdx,4), %rcx
movl 0xc(%rsp), %edi
movl (%rsi,%rdi,4), %esi
incl %esi
cmpl %esi, %ecx
jne 0x814f
movq 0x37150(%rip), %rsi     # 0x3f268
leaq (%rcx,%rcx,4), %r8
shlq $0x4, %r8
leaq (%rsi,%r8), %rdi
movq 0x30(%rsi,%r8), %rcx
movq 0x40(%rsi,%r8), %rsi
addq $-0x4, %rsi
cmpq %rsi, %rcx
je 0x8143
movl %edx, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x30(%rdi)
jmp 0x814f
movq %r12, %rsi
callq 0x75be
movq (%r13), %rax
incq %rbx
movl 0x4(%rsp), %ecx
leaq (%rcx,%rcx,2), %rdi
movq (%rax,%rdi,8), %rdx
movq 0x8(%rax,%rdi,8), %rsi
movq %rsi, %r8
subq %rdx, %r8
sarq $0x2, %r8
cmpq %rbx, %r8
ja 0x80b0
leaq (%rax,%rdi,8), %rax
movq 0x10(%rsp), %rbx
jmp 0x8185
leaq (%rax,%rdi,8), %rax
cmpq %rdx, %rsi
je 0x818e
movq %rdx, 0x8(%rax)
movl 0xc(%rsp), %eax
movq 0x370af(%rip), %rdx     # 0x3f248
movl (%rdx,%rax,4), %eax
movl %eax, (%rdx,%rcx,4)
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x81c6
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x70(%rsp)
jmp 0x81de
leaq 0x40(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x75be
movl 0x4(%rsp), %ecx
movq 0x70(%rsp), %rax
movl 0xc(%rsp), %edx
movq 0x30(%r13), %rsi
movl (%rsi,%rdx,4), %edx
incl %edx
movl %ecx, %ecx
movl %edx, (%rsi,%rcx,4)
movl 0xc(%rsp), %ecx
movq 0x18(%r13), %rdx
movq 0xc0(%r13), %rsi
movl (%rdx,%rcx,4), %ecx
movl 0x4(%rsp), %edx
movl %ecx, (%rsi,%rdx,4)
movl 0x4(%rsp), %ecx
movq 0xd8(%r13), %rdx
movl %ecx, %esi
movl $0x1, %edi
shlq %cl, %rdi
shrl $0x6, %esi
orq %rdi, (%rdx,%rsi,8)
leaq 0xd8(%r13), %rcx
movq %rcx, 0x28(%rsp)
movq 0x50(%rsp), %rcx
cmpq %rcx, %rax
je 0x862b
leaq 0x8(%rsp), %rbp
leaq 0x90(%rsp), %r14
movq %r14, %r12
movl (%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%r13), %rcx
movslq (%rcx,%rax,4), %rdx
movq 0x3700c(%rip), %rsi     # 0x3f270
movq 0x36ffd(%rip), %rcx     # 0x3f268
subq %rcx, %rsi
sarq $0x4, %rsi
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdi, %rsi
cmpq %rdx, %rsi
jbe 0x82b7
leaq (%rdx,%rdx,4), %rsi
shlq $0x4, %rsi
leaq (%rcx,%rsi), %rdi
movq 0x30(%rcx,%rsi), %rdx
movq 0x40(%rcx,%rsi), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rdx
je 0x833f
movl %eax, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rdi)
jmp 0x8359
xorpd %xmm0, %xmm0
movapd %xmm0, 0xd0(%rsp)
movapd %xmm0, 0xc0(%rsp)
movapd %xmm0, 0xb0(%rsp)
movapd %xmm0, 0xa0(%rsp)
movapd %xmm0, 0x90(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x6ad0
leaq 0x36f6f(%rip), %rdi     # 0x3f268
movq %r14, %rsi
callq 0x8dde
movl 0x8(%rsp), %eax
movq 0x30(%r13), %rcx
movslq (%rcx,%rax,4), %rcx
movq 0x36f54(%rip), %rdx     # 0x3f268
leaq (%rcx,%rcx,4), %rsi
shlq $0x4, %rsi
leaq (%rdx,%rsi), %rdi
movq 0x30(%rdx,%rsi), %rcx
movq 0x40(%rdx,%rsi), %rdx
addq $-0x4, %rdx
cmpq %rdx, %rcx
je 0x8349
movl %eax, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x30(%rdi)
jmp 0x8351
movq %rbp, %rsi
callq 0x75be
jmp 0x8359
movq %rbp, %rsi
callq 0x75be
movq %r12, %rdi
callq 0x690a
movq 0x50(%rsp), %rax
movq 0x60(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x8372
addq $0x4, %rax
jmp 0x83a4
movq 0x58(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2250
movq 0x68(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x50(%rsp)
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x2e734
movq %r12, %rdi
movq %rax, %rsi
callq 0x6112
movq 0x90(%rsp), %rdi
cmpq %rdi, 0x98(%rsp)
je 0x8603
xorl %ebx, %ebx
movl (%rdi,%rbx,4), %eax
movl %eax, (%rsp)
movq 0x30(%r13), %rdx
movl 0x8(%rsp), %ecx
movl (%rdx,%rcx,4), %esi
incl %esi
cmpl %esi, (%rdx,%rax,4)
jle 0x8426
movl %esi, (%rdx,%rax,4)
movl (%rsp), %eax
movq 0x36e2b(%rip), %rcx     # 0x3f228
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x84ab
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x84b3
jne 0x85db
movq 0xc0(%r13), %rdx
movl (%rdx,%rcx,4), %ecx
addl %ecx, (%rdx,%rax,4)
movl 0x8(%rsp), %eax
movl (%rdx,%rax,4), %eax
movl (%rsp), %ecx
movq 0x36dfe(%rip), %rdx     # 0x3f248
addl %eax, (%rdx,%rcx,4)
movl (%rsp), %eax
movq (%r13), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %rdi
movq 0x8(%rcx,%rax,8), %rsi
movq %rbp, %rdx
callq 0x7b97
movl (%rsp), %ecx
movq (%r13), %rdx
leaq (%rcx,%rcx,2), %rcx
cmpq 0x8(%rdx,%rcx,8), %rax
jne 0x8582
movq 0x36da2(%rip), %rax     # 0x3f228
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x857a
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x8582
movq %rbp, %rdx
callq 0x6f14
movl (%rsp), %eax
movq (%r13), %rsi
leaq (%rax,%rax,2), %r8
movq (%rsi,%r8,8), %rcx
movq 0x8(%rsi,%r8,8), %rdx
movq %rdx, %rdi
subq %rcx, %rdi
je 0x8543
leaq (%rsi,%r8,8), %rsi
sarq $0x2, %rdi
movq 0x30(%rsp), %r8
movq (%r8), %r8
cvtsi2sdl (%r8,%rax,4), %xmm0
movq 0x20(%rsp), %r9
movq (%r9), %r9
movq (%r15), %r10
cmpq $0x1, %rdi
adcq $0x0, %rdi
xorl %r11d, %r11d
movsd 0x27b2d(%rip), %xmm4    # 0x30030
movl (%rcx,%r11,4), %r14d
xorps %xmm1, %xmm1
cvtsi2sdl (%r8,%r14,4), %xmm1
divsd %xmm0, %xmm1
movsd (%r9,%rax,8), %xmm2
addsd %xmm4, %xmm2
movsd (%r10,%r14,8), %xmm3
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm3
movsd %xmm3, (%r10,%r14,8)
incq %r11
cmpq %r11, %rdi
jne 0x8503
cmpq %rcx, %rdx
je 0x8543
movq %rcx, 0x8(%rsi)
movq 0x36cfe(%rip), %rcx     # 0x3f248
movl $0x0, (%rcx,%rax,4)
movl 0x8(%rsp), %eax
movq 0xc0(%r13), %rdx
movl (%rdx,%rax,4), %eax
movl (%rsp), %esi
movl %eax, (%rdx,%rsi,4)
movl (%rsp), %eax
movl (%rdx,%rax,4), %edx
addl %edx, (%rcx,%rax,4)
movl (%rsp), %ecx
movq 0xd8(%r13), %rax
jmp 0x858d
movq %rbp, %rdx
callq 0x6f14
movl (%rsp), %ecx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl $0x1, %edx
shlq %cl, %rdx
movl %ecx, %esi
shrl $0x6, %esi
movq (%rax,%rsi,8), %rdi
btq %rcx, %rdi
jb 0x85db
orq %rdi, %rdx
movq %rdx, (%rax,%rsi,8)
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $-0x4, %rdx
cmpq %rdx, %rax
je 0x85ce
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x70(%rsp)
jmp 0x85db
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x75be
incq %rbx
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rax
subq %rdi, %rax
sarq $0x2, %rax
cmpq %rbx, %rax
ja 0x83d8
movq 0x10(%rsp), %rbx
testq %rdi, %rdi
je 0x8618
movq 0xa0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x50(%rsp), %rcx
cmpq %rcx, 0x70(%rsp)
movq %r12, %r14
jne 0x824f
movq %rbx, %rdi
callq 0x2e9da
movq 0x28(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x8e0a
movq 0x36c27(%rip), %rcx     # 0x3f270
movq 0x36c18(%rip), %rax     # 0x3f268
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
movl %ecx, %edx
decl %edx
js 0x896b
movl %edx, %ebx
movl %ecx, %edx
leaq (%rbx,%rbx,4), %rbp
shlq $0x4, %rbp
movq 0x30(%rax,%rbp), %rcx
cmpq 0x10(%rax,%rbp), %rcx
movq %rdx, 0xe0(%rsp)
je 0x8950
addq %rbp, %rax
leal -0x2(%rdx), %r14d
movq %rax, %rdi
movq %rbp, 0x10(%rsp)
cmpq 0x38(%rdi), %rcx
jne 0x86b8
movq 0x48(%rdi), %rax
movq -0x8(%rax), %rcx
movl $0x200, %eax            # imm = 0x200
addq %rax, %rcx
movl -0x4(%rcx), %r12d
callq 0x9d18
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl $0x1, %edx
movl %r12d, %ecx
shlq %cl, %rdx
movl %r12d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rsi
btq %r12, %rsi
jb 0x8935
orq %rdx, %rsi
movq %rsi, (%rax,%rcx,8)
movq (%r13), %rax
leaq (%r12,%r12,2), %r13
movq (%rax,%r13,8), %rcx
cmpq %rcx, 0x8(%rax,%r13,8)
je 0x87f9
xorl %ebp, %ebp
movl (%rcx,%rbp,4), %ecx
movl %ecx, 0x90(%rsp)
movq 0x30(%rsp), %rdx
movq (%rdx), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%rcx,4), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%r12,4), %xmm1
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rdx
movq (%rdx), %rdx
movsd (%rdx,%r12,8), %xmm1
movsd 0x278eb(%rip), %xmm3    # 0x30030
addsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movq (%r15), %rdx
movsd (%rdx,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rcx,8)
movq 0x36ae3(%rip), %rsi     # 0x3f248
xorps %xmm1, %xmm1
cvtsi2sdl (%rsi,%rcx,4), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl (%rsi,%r12,4), %xmm2
divsd %xmm2, %xmm1
movsd (%rdx,%r12,8), %xmm2
addsd %xmm3, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rdx,%rcx,8)
testq %rbx, %rbx
je 0x87dd
movq 0x36acb(%rip), %rsi     # 0x3f268
leaq (%r14,%r14,4), %r8
shlq $0x4, %r8
leaq (%rsi,%r8), %rdi
movq 0x30(%rsi,%r8), %rdx
movq 0x40(%rsi,%r8), %rsi
addq $-0x4, %rsi
cmpq %rsi, %rdx
je 0x87c8
movl %ecx, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rdi)
jmp 0x87dd
leaq 0x90(%rsp), %rsi
callq 0x75be
movq 0x18(%rsp), %rax
movq (%rax), %rax
incq %rbp
movq (%rax,%r13,8), %rcx
movq 0x8(%rax,%r13,8), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rbp, %rdx
ja 0x8708
movq 0x36a28(%rip), %rcx     # 0x3f228
movq (%rcx,%r13,8), %rdx
cmpq %rdx, 0x8(%rcx,%r13,8)
je 0x88cb
xorl %ebp, %ebp
movl (%rdx,%rbp,4), %eax
movl %eax, 0x90(%rsp)
movq 0x36a26(%rip), %rdx     # 0x3f248
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%r12,4), %xmm1
divsd %xmm1, %xmm0
movq (%r15), %rdx
movsd (%rdx,%r12,8), %xmm1
addsd 0x277e8(%rip), %xmm1    # 0x30030
mulsd %xmm0, %xmm1
addsd (%rdx,%rax,8), %xmm1
movsd %xmm1, (%rdx,%rax,8)
testq %rbx, %rbx
je 0x88a1
movq 0x36a06(%rip), %rsi     # 0x3f268
leaq (%r14,%r14,4), %r8
shlq $0x4, %r8
leaq (%rsi,%r8), %rdi
movq 0x30(%rsi,%r8), %rdx
movq 0x40(%rsi,%r8), %rsi
addq $-0x4, %rsi
cmpq %rsi, %rdx
je 0x888d
movl %eax, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rdi)
jmp 0x88a1
leaq 0x90(%rsp), %rsi
callq 0x75be
movq 0x36987(%rip), %rcx     # 0x3f228
incq %rbp
movq (%rcx,%r13,8), %rdx
movq 0x8(%rcx,%r13,8), %rax
subq %rdx, %rax
sarq $0x2, %rax
cmpq %rbp, %rax
ja 0x8811
leaq (%rcx,%r13,8), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
jmp 0x88cf
leaq (%rcx,%r13,8), %rsi
leaq (%rax,%r13,8), %rdi
callq 0x5d4e
movq 0x10(%rsp), %rbp
cmpl 0x3c(%rsp), %r12d
movq 0x18(%rsp), %r13
je 0x8935
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%r12,8), %xmm0
movsd 0x27739(%rip), %xmm2    # 0x30038
mulsd %xmm2, %xmm0
movq 0xe8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r12,8)
movq (%r15), %rcx
movsd (%rcx,%r12,8), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r12,8)
movq 0x3692c(%rip), %rax     # 0x3f268
leaq (%rax,%rbp), %rdi
movq 0x30(%rax,%rbp), %rcx
cmpq 0x10(%rax,%rbp), %rcx
jne 0x86a2
leaq -0x1(%rbx), %rcx
movq 0xe0(%rsp), %rdx
decq %rdx
testq %rbx, %rbx
movq %rcx, %rbx
jg 0x8673
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x8b1e
leaq 0x368c9(%rip), %rsi     # 0x3f248
movq 0x30(%rsp), %rdi
callq 0x8c34
movq 0xc0(%r13), %rdi
movq 0xc8(%r13), %rdx
cmpq %rdx, %rdi
je 0x89b2
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x2110
movq 0xd8(%r13), %rdi
movq 0xe8(%r13), %r14
movl 0xf0(%r13), %ebx
cmpq %r14, %rdi
je 0x89db
movq %r14, %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x2110
jmp 0x89de
movq %rdi, %r14
testl %ebx, %ebx
je 0x89f6
negb %bl
movq $-0x1, %rax
movl %ebx, %ecx
shrq %cl, %rax
notq %rax
andq %rax, (%r14)
leaq 0x40(%rsp), %rdi
callq 0x690a
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24bb
jmp 0x7f1b
leaq 0x3683d(%rip), %rdi     # 0x3f260
callq 0x23d0
testl %eax, %eax
je 0x7f7f
leaq 0x78(%r13), %rsi
leaq 0x3680d(%rip), %rdi     # 0x3f248
callq 0x7afc
leaq 0xbf(%rip), %rdi        # 0x8b06
leaq 0x367fa(%rip), %rsi     # 0x3f248
leaq 0x367b3(%rip), %rdx     # 0x3f208
callq 0x2200
leaq 0x367ff(%rip), %rdi     # 0x3f260
callq 0x2170
movq 0x18(%rsp), %r13
jmp 0x7f7f
callq 0x2507
jmp 0x7fa9
movq %rax, %rbx
leaq 0x367dc(%rip), %rdi     # 0x3f260
callq 0x2160
jmp 0x8afe
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
testq %rdi, %rdi
je 0x8afe
movq 0x100(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
jmp 0x8afe
jmp 0x8af1
jmp 0x8af1
jmp 0x8af1
jmp 0x8af1
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x690a
jmp 0x8af4
jmp 0x8af1
jmp 0x8acb
movq %rax, %rbx
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x8af4
movq 0xa0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
jmp 0x8af4
jmp 0x8af1
jmp 0x8af1
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x690a
movq %rbx, %rdi
callq 0x23b0