// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rcx, %r12
movl %edx, 0x34(%rsp)
movq %rsi, %r13
movq %rdi, 0x40(%rsp)
leaq 0x48(%r8), %rsi
leaq 0x90(%r8), %rdi
movq %rdi, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
callq 0x743c
movb 0x3273b(%rip), %al      # 0x39258
testb %al, %al
je 0x72c3
movq %r13, %rdi
callq 0x2622a
xorpd %xmm0, %xmm0
leaq 0xa0(%rsp), %rdx
movapd %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x326f7(%rip), %rdi     # 0x39240
movq %rax, %rsi
callq 0x7506
leaq 0xa0(%rsp), %rdi
callq 0x56ec
movb 0x32714(%rip), %al      # 0x39278
testb %al, %al
movq %r15, 0x28(%rsp)
je 0x7316
movq %r12, %rbx
shrq $0x20, %rbx
leaq 0x18(%r15), %rsi
leaq 0x326dd(%rip), %rdi     # 0x39260
movq %rsi, 0x38(%rsp)
callq 0x752c
movb 0x32705(%rip), %al      # 0x39298
testb %al, %al
je 0x736a
leaq 0xb8(%rsp), %rdi
callq 0x4a40
movl %r12d, %eax
movq 0x30(%r15), %rcx
movl (%rcx,%rax,4), %eax
cmpl (%rcx,%rbx,4), %eax
movl %r12d, %eax
cmovgl %ebx, %eax
cmovgl %r12d, %ebx
movl %eax, 0x4(%rsp)
movl %ebx, 0x8(%rsp)
movslq (%rcx,%rbx,4), %rsi
incq %rsi
leaq 0x326ab(%rip), %rdi     # 0x39280
callq 0x7618
movl 0x8(%rsp), %eax
movq 0x30(%r15), %rcx
movl 0x4(%rsp), %edx
movl (%rcx,%rdx,4), %edx
incl %edx
imulq $0x18, %rax, %rdi
addq 0x3264a(%rip), %rdi     # 0x39240
cmpl %edx, (%rcx,%rax,4)
jne 0x6c1f
leaq 0x4(%rsp), %rsi
callq 0x478c
movl 0x4(%rsp), %eax
movq 0x32650(%rip), %rcx     # 0x39260
movl (%rcx,%rax,4), %eax
movl 0x8(%rsp), %edx
addl %eax, (%rcx,%rdx,4)
jmp 0x6cef
leaq 0x4(%rsp), %rsi
callq 0x478c
xorl %ebx, %ebx
movsd 0x2140d(%rip), %xmm2    # 0x28040
leaq 0x50(%rsp), %r14
movl 0x8(%rsp), %eax
movq (%r15), %rcx
imulq $0x18, %rax, %rsi
movq (%rcx,%rsi), %rdx
movq 0x8(%rcx,%rsi), %rdi
movq %rdi, %r8
subq %rdx, %r8
sarq $0x2, %r8
cmpq %rbx, %r8
jbe 0x6cd2
movl (%rdx,%rbx,4), %ecx
movl %ecx, 0x50(%rsp)
movq 0x18(%r15), %rdx
movq 0x48(%r15), %rsi
cvtsi2sdl (%rdx,%rcx,4), %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm1
divsd %xmm1, %xmm0
movsd (%rsi,%rax,8), %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movq 0x90(%r15), %rax
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x30(%r15), %rdx
movslq (%rdx,%rcx,4), %rax
movl 0x4(%rsp), %ecx
movl (%rdx,%rcx,4), %ecx
incl %ecx
cmpl %ecx, %eax
jne 0x6cca
imulq $0x50, %rax, %rdi
addq 0x325c6(%rip), %rdi     # 0x39280
movq %r14, %rsi
callq 0x62da
movsd 0x21376(%rip), %xmm2    # 0x28040
incq %rbx
jmp 0x6c38
cmpq %rdx, %rdi
je 0x6cde
addq %rsi, %rcx
movq %rdx, 0x8(%rcx)
movl 0x4(%rsp), %ecx
movq 0x32577(%rip), %rdx     # 0x39260
movl (%rdx,%rcx,4), %ecx
movl %ecx, (%rdx,%rax,4)
leaq 0xb8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62da
leaq 0xd8(%r15), %rdi
movl 0x4(%rsp), %eax
movq 0x30(%r15), %rcx
movl (%rcx,%rax,4), %eax
incl %eax
movl 0x8(%rsp), %edx
movl %eax, (%rcx,%rdx,4)
movl 0x4(%rsp), %eax
movq 0x18(%r15), %rcx
movq 0xc0(%r15), %rdx
movl (%rcx,%rax,4), %eax
movl 0x8(%rsp), %ecx
movl %eax, (%rdx,%rcx,4)
movl 0x8(%rsp), %esi
movq %rdi, 0x10(%rsp)
callq 0x4b82
orq %rdx, (%rax)
leaq 0xc(%rsp), %rbp
leaq 0x50(%rsp), %r14
movq 0xc8(%rsp), %rax
cmpq %rax, 0xe8(%rsp)
je 0x6fc8
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%r15), %rcx
movslq (%rcx,%rax,4), %rcx
movq 0x3250d(%rip), %rax     # 0x39288
movq 0x324fe(%rip), %rdi     # 0x39280
subq %rdi, %rax
cqto
pushq $0x50
popq %rsi
idivq %rsi
cmpq %rcx, %rax
jbe 0x6da3
imulq $0x50, %rcx, %rax
addq %rax, %rdi
movq %rbp, %rsi
callq 0x62da
jmp 0x6de1
movq %r14, %rdi
callq 0x766a
leaq 0x324ce(%rip), %rdi     # 0x39280
movq %r14, %rsi
callq 0x7686
movl 0xc(%rsp), %eax
movq 0x30(%r15), %rcx
movslq (%rcx,%rax,4), %rax
imulq $0x50, %rax, %rdi
addq 0x324af(%rip), %rdi     # 0x39280
movq %rbp, %rsi
callq 0x62da
movq %r14, %rdi
callq 0x5280
leaq 0xb8(%rsp), %rdi
callq 0x650e
movl 0xc(%rsp), %esi
movq %r13, %rdi
callq 0x25fe0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ba0
xorl %r12d, %r12d
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x6fbb
movl (%rax,%r12,4), %eax
movl %eax, (%rsp)
movq 0x30(%r15), %rdx
movl 0xc(%rsp), %ecx
movl (%rdx,%rcx,4), %esi
incl %esi
cmpl %esi, (%rdx,%rax,4)
jle 0x6ecd
movl %esi, (%rdx,%rax,4)
movl (%rsp), %eax
imulq $0x18, %rax, %rdi
addq 0x323f0(%rip), %rdi     # 0x39240
movq %rbp, %rsi
callq 0x478c
movl (%rsp), %eax
imulq $0x18, %rax, %rdi
movq (%r15), %r8
movq 0x18(%r15), %rsi
leaq (%r8,%rdi), %rcx
movq (%r8,%rdi), %rdx
movq 0x8(%r8,%rdi), %rdi
movq %rdi, %r8
subq %rdx, %r8
sarq $0x2, %r8
movq 0x48(%r15), %r9
movq 0x90(%r15), %r10
xorl %r11d, %r11d
cmpq %r11, %r8
je 0x6f50
movl (%rdx,%r11,4), %ebx
cvtsi2sdl (%rsi,%rbx,4), %xmm0
cvtsi2sdl (%rsi,%rax,4), %xmm1
divsd %xmm1, %xmm0
movsd (%r9,%rax,8), %xmm1
addsd 0x2118c(%rip), %xmm1    # 0x28040
mulsd %xmm0, %xmm1
movsd (%r10,%rbx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r10,%rbx,8)
incq %r11
jmp 0x6e8b
jne 0x6fb3
movq 0xc0(%r15), %rdx
movl (%rdx,%rcx,4), %ecx
addl %ecx, (%rdx,%rax,4)
movl 0xc(%rsp), %eax
movl (%rdx,%rax,4), %eax
movl (%rsp), %ecx
movq 0x3236f(%rip), %rdx     # 0x39260
addl %eax, (%rdx,%rcx,4)
movl (%rsp), %eax
movq (%r15), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rcx,%rax), %rsi
movq %rbp, %rdx
callq 0x688c
movl (%rsp), %esi
movq (%r15), %rcx
imulq $0x18, %rsi, %rdi
cmpq 0x8(%rcx,%rdi), %rax
jne 0x6f32
addq 0x32319(%rip), %rdi     # 0x39240
movq %rbp, %rsi
callq 0x478c
movl (%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0x4b82
testq %rdx, (%rax)
jne 0x6fb3
movl (%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0x4b82
jmp 0x6fa0
cmpq %rdx, %rdi
je 0x6f59
movq %rdx, 0x8(%rcx)
movq 0x32300(%rip), %rcx     # 0x39260
andl $0x0, (%rcx,%rax,4)
movl 0xc(%rsp), %eax
movq 0xc0(%r15), %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), %esi
movq 0x10(%rsp), %rdi
callq 0x4b82
testq %rdx, (%rax)
jne 0x6fb3
movl (%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0x4b82
orq %rdx, (%rax)
leaq 0xb8(%rsp), %rdi
movq %rsp, %rsi
callq 0x62da
incq %r12
jmp 0x6e08
movq %r14, %rdi
callq 0x56ec
jmp 0x6d50
movq %r13, %rdi
callq 0x2622a
movq 0x10(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x76b2
movq 0x322a2(%rip), %rax     # 0x39288
movq 0x32293(%rip), %rcx     # 0x39280
subq %rcx, %rax
cqto
pushq $0x50
popq %rsi
idivq %rsi
movl %eax, %eax
leaq 0x50(%rsp), %rbp
leaq -0x1(%rax), %r13
testl %r13d, %r13d
js 0x7243
movl %r13d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addl $-0x2, %eax
imulq $0x50, %rdx, %r14
imulq $0x50, %rax, %rbx
movq %r14, 0x48(%rsp)
leaq (%rcx,%r14), %rdi
movq 0x30(%rcx,%r14), %rax
cmpq 0x10(%rcx,%r14), %rax
je 0x723b
cmpq 0x38(%rdi), %rax
jne 0x704f
movq 0x48(%rdi), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movl -0x4(%rax), %r12d
callq 0x85f6
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x4b82
testq %rdx, (%rax)
jne 0x722f
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x4b82
orq %rdx, (%rax)
imulq $0x18, %r12, %r14
xorl %r15d, %r15d
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq (%rcx,%r14), %rax
movq 0x8(%rcx,%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x7145
movl (%rax,%r15,4), %eax
movl %eax, 0x50(%rsp)
movq 0x38(%rsp), %rcx
movq (%rcx), %rcx
cvtsi2sdl (%rcx,%rax,4), %xmm0
cvtsi2sdl (%rcx,%r12,4), %xmm1
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rcx,%r12,8), %xmm1
movsd 0x20f65(%rip), %xmm3    # 0x28040
addsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rcx,%rax,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rax,8)
movq 0x32160(%rip), %rdx     # 0x39260
cvtsi2sdl (%rdx,%rax,4), %xmm1
cvtsi2sdl (%rdx,%r12,4), %xmm2
divsd %xmm2, %xmm1
movsd (%rcx,%r12,8), %xmm2
addsd %xmm3, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rax,8)
testl %r13d, %r13d
je 0x713d
movq 0x3214e(%rip), %rdi     # 0x39280
addq %rbx, %rdi
movq %rbp, %rsi
callq 0x62da
incq %r15
jmp 0x7085
xorl %r15d, %r15d
movq 0x320f1(%rip), %rsi     # 0x39240
movq (%rsi,%r14), %rax
movq 0x8(%rsi,%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x71c2
movl (%rax,%r15,4), %eax
movl %eax, 0x50(%rsp)
movq 0x320ed(%rip), %rcx     # 0x39260
cvtsi2sdl (%rcx,%rax,4), %xmm0
cvtsi2sdl (%rcx,%r12,4), %xmm1
divsd %xmm1, %xmm0
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rcx,%r12,8), %xmm1
addsd 0x20ea8(%rip), %xmm1    # 0x28040
mulsd %xmm0, %xmm1
addsd (%rcx,%rax,8), %xmm1
movsd %xmm1, (%rcx,%rax,8)
testl %r13d, %r13d
je 0x71bd
movq 0x320ce(%rip), %rdi     # 0x39280
addq %rbx, %rdi
movq %rbp, %rsi
callq 0x62da
incq %r15
jmp 0x7148
addq %r14, %rsi
movq 0x28(%rsp), %r15
addq (%r15), %r14
movq %r14, %rdi
callq 0x47aa
cmpl 0x34(%rsp), %r12d
movq 0x48(%rsp), %r14
je 0x722f
movq 0x20(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%r12,8), %xmm0
movsd 0x20e39(%rip), %xmm2    # 0x28030
mulsd %xmm2, %xmm0
movq 0x40(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r12,8)
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rcx,%r12,8), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r12,8)
movq 0x3204a(%rip), %rcx     # 0x39280
jmp 0x7025
movq %r13, %rax
jmp 0x6fff
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x743c
leaq 0x32007(%rip), %rsi     # 0x39260
movq 0x38(%rsp), %rdi
callq 0x752c
movq 0xc0(%r15), %rax
movq 0xc8(%r15), %rcx
cmpq %rcx, %rax
je 0x727f
andl $0x0, (%rax)
addq $0x4, %rax
jmp 0x7271
movq 0xd8(%r15), %rdi
movq 0xe8(%r15), %rdx
movl 0xf0(%r15), %ecx
leaq 0x50(%rsp), %r8
movb $0x0, (%r8)
xorl %esi, %esi
callq 0x864b
leaq 0xb8(%rsp), %rdi
callq 0x5280
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31f8e(%rip), %rdi     # 0x39258
callq 0x23f0
testl %eax, %eax
je 0x6b25
xorpd %xmm0, %xmm0
movupd %xmm0, 0x31f5d(%rip)    # 0x39240
andq $0x0, 0x31f65(%rip)     # 0x39250
leaq 0x31f4e(%rip), %rsi     # 0x39240
leaq -0x28db(%rip), %rdi     # 0x4a1e
leaq 0x31f20(%rip), %rdx     # 0x39220
callq 0x2200
leaq 0x31f4c(%rip), %rdi     # 0x39258
callq 0x2170
jmp 0x6b25
leaq 0x31f5b(%rip), %rdi     # 0x39278
callq 0x23f0
testl %eax, %eax
je 0x6b71
leaq 0x78(%r15), %rsi
leaq 0x31f2b(%rip), %rdi     # 0x39260
callq 0x6766
leaq 0xf5(%rip), %rdi        # 0x7436
leaq 0x31f18(%rip), %rsi     # 0x39260
leaq 0x31ed1(%rip), %rdx     # 0x39220
callq 0x2200
leaq 0x31f1d(%rip), %rdi     # 0x39278
callq 0x2170
movq 0x28(%rsp), %r15
jmp 0x6b71
leaq 0x31f27(%rip), %rdi     # 0x39298
callq 0x23f0
testl %eax, %eax
je 0x6b9b
xorpd %xmm0, %xmm0
movupd %xmm0, 0x31ef6(%rip)    # 0x39280
andq $0x0, 0x31efe(%rip)     # 0x39290
leaq 0x31ee7(%rip), %rsi     # 0x39280
leaq 0x256(%rip), %rdi       # 0x75f6
leaq 0x31e79(%rip), %rdx     # 0x39220
callq 0x2200
leaq 0x31ee5(%rip), %rdi     # 0x39298
callq 0x2170
jmp 0x6b9b
movq %rax, %rbx
leaq 0x31eb1(%rip), %rdi     # 0x39278
callq 0x2160
jmp 0x742e
jmp 0x741e
jmp 0x741e
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x56ec
jmp 0x742e
jmp 0x741e
jmp 0x741e
jmp 0x741e
jmp 0x741e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5280
jmp 0x7421
jmp 0x741e
jmp 0x740b
jmp 0x740b
jmp 0x740b
jmp 0x740b
jmp 0x741e
jmp 0x741e
jmp 0x740b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x56ec
jmp 0x7421
jmp 0x741e
jmp 0x741e
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x23d0