LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::insert_new(node*)
node * BinarySearchTree::insert_new(node *nn) {
    if(!nn)
        return new node();
    change_root(nn);
    while(nn->right)
        nn = nn->right;
    node * newnode = new node();
    newnode->par = nn;
    nn->right = newnode;
    nn->update();
    change_root(newnode);
    return newnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x26bc
movq %rdi, %rbx
callq 0x26e6
movq %rbx, %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2674
movl $0x30, %edi
callq 0x21a0
movq %rax, %rbx
movl $0x1, 0x1c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x2608
movq %rbx, %rdi
callq 0x26e6
jmp 0x26de
movl $0x30, %edi
callq 0x21a0
movq %rax, %rbx
movl $0x1, 0x1c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x20(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::change_root(node*)
void BinarySearchTree::change_root(node * nn) {
    if(!nn)
        return;
    while(nn->par) {
        node * p = nn->par;
        node * gp = p->par;
        if(!gp) {
            rotate(nn);
            break;
        }

        if((nn == p->left) == (p == gp->left)) {
            rotate(p);          //left child, left child case
            rotate(nn);             //or right, right case
        }
        else {
            rotate(nn);         //zig zag 
            rotate(nn);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2727
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2727
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x272e
cmpq %rbx, (%rdi)
sete %cl
cmpq (%rax), %rdi
setne %al
xorb %cl, %al
cmoveq %rbx, %rdi
callq 0x27de
movq %rbx, %rdi
callq 0x27de
jmp 0x26f4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27de
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rotate_left(node*)
void BinarySearchTree::rotate_left(node* nn) {
    node * p = nn->par;
    node * gp = p->par;
    node * lc = nn->left;
    nn->par = gp;

    if(gp) {
        if(p == gp->left)
            gp->left = nn;
        else
            gp->right = nn;
    }

    nn->left = p;
    p->par = nn;

    p->right = lc;
    if(lc)
        lc->par = p;
    p->update();
    nn->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rbx)
testq %rcx, %rcx
je 0x2765
xorl %edx, %edx
cmpq (%rcx), %rdi
setne %dl
movq %rbx, (%rcx,%rdx,8)
movq %rdi, (%rbx)
movq %rbx, 0x10(%rdi)
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x2779
movq %rdi, 0x10(%rax)
callq 0x2608
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2608
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rotate_right(node*)
void BinarySearchTree::rotate_right(node * nn) {
    node * p = nn->par;
    node * gp = p->par;
    node * rc = nn->right;
    nn->par = gp;

    if(gp) {
        if(p == gp->left)
            gp->left = nn;
        else
            gp->right = nn;
    }

    nn->right = p;
    p->par = nn;

    p->left = rc;
    if(rc)
        rc->par = p;
    p->update();
    nn->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rbx)
testq %rcx, %rcx
je 0x27b6
xorl %edx, %edx
cmpq (%rcx), %rdi
setne %dl
movq %rbx, (%rcx,%rdx,8)
movq %rdi, 0x8(%rbx)
movq %rbx, 0x10(%rdi)
movq %rax, (%rdi)
testq %rax, %rax
je 0x27ca
movq %rdi, 0x10(%rax)
callq 0x2608
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2608
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rotate(node*)
void BinarySearchTree::rotate(node * nn) {
    node * p = nn->par;
    if(!p)
        return;
    if(nn == p->left)
        rotate_right(nn);
    else
        rotate_left(nn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x27f6
cmpq %rdi, (%rax)
je 0x27f8
popq %rbp
jmp 0x273c
popq %rbp
retq
popq %rbp
jmp 0x278c
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::remove_child(node*)
void BinarySearchTree::remove_child(node * nn) {
    node * p = nn->par;
    if(!p)
        return;
    if(nn == p->left)
        p->left = NULL;
    else
        p->right = NULL;
    nn->par = NULL;
    p->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2826
xorl %ecx, %ecx
cmpq %rax, (%rdi)
setne %cl
xorl %edx, %edx
movq %rdx, (%rdi,%rcx,8)
movq %rdx, 0x10(%rax)
popq %rbp
jmp 0x2608
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::delete_node(node*)
void BinarySearchTree::delete_node(node * nn) {
    change_root(nn);

    node * l = nn->left;
    node * r = nn->right;

    if(!l && !r) {
        return;
    }
    else if(!l) {
        remove_child(r);
    }
    else if(!r) {
        remove_child(l);
    }
    else {
        remove_child(l);
        remove_child(r);
        node * newroot = leftmost(r);
        newroot->left = l;
        newroot->update();
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x26e6
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq %r14, %rax
orq %rbx, %rax
je 0x28e1
testq %r14, %r14
je 0x28a4
movq 0x10(%r14), %rdi
testq %rbx, %rbx
je 0x28c1
testq %rdi, %rdi
je 0x2874
xorl %eax, %eax
cmpq %r14, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%r14)
callq 0x2608
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2894
xorl %eax, %eax
cmpq %rbx, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%rbx)
callq 0x2608
movq %rbx, %rdi
callq 0x28e6
movq %rax, %rdi
movq %r14, (%rax)
jmp 0x28d8
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x28e1
xorl %eax, %eax
cmpq %rbx, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%rbx)
jmp 0x28d8
testq %rdi, %rdi
je 0x28e1
xorl %eax, %eax
cmpq %r14, (%rdi)
setne %al
xorl %ecx, %ecx
movq %rcx, (%rdi,%rax,8)
movq %rcx, 0x10(%r14)
popq %rbx
popq %r14
popq %rbp
jmp 0x2608
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::leftmost(node*)
node * BinarySearchTree::leftmost(node * nn) {
    change_root(nn);
    while(nn->left)
        nn = nn->left;
    change_root(nn);
    return nn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x26e6
movq %rbx, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x28f5
movq %r14, %rdi
callq 0x26e6
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::next_in_seq(node*)
node * BinarySearchTree::next_in_seq(node * nn) {
    change_root(nn);
    nn = nn->right;
    if(!nn)
        return NULL;
    while(nn->left)
        nn = nn->left;
    change_root(nn);
    return nn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x26e6
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x293c
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x2927
movq %rbx, %rdi
callq 0x26e6
jmp 0x293e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/BinarySearchTree.cpp
// Function: BinarySearchTree::rightmost(node*)
node * BinarySearchTree::rightmost(node * nn) {
    change_root(nn);
    while(nn->right)
        nn=nn->right;
    change_root(nn);
    return nn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x26e6
movq %rbx, %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2957
movq %r14, %rdi
callq 0x26e6
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::get_edge(int, int)
node * EulerTourTree::get_edge(int u, int v) {
    pair <int ,int> p = make_pair(u, v);
    auto it = edgemap.find(p);
    if(it == edgemap.end())
        return NULL;
    return it->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq -0x8(%rbp), %rsi
movq %rax, (%rsi)
addq $0x70, %rdi
callq 0x33b2
testq %rax, %rax
je 0x29d6
movq 0x10(%rax), %rax
jmp 0x29d8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::add_node(int, node*)
void EulerTourTree::add_node(int u, node * nn) {
    BinarySearchTree::change_root(nn);
    NodeSet[u].insert(nn);
    if(!IDtoNode.count(u)) {
        IDtoNode[u]=nn;
        nn->adjacent_nodes[0] = adj_map[0][u];
        nn->adjacent_nodes[1] = adj_map[1][u];
    }
    nn->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x1c(%rbp), %r14
movl %esi, (%r14)
leaq -0x28(%rbp), %r15
movq %rdx, (%r15)
movq %rdx, %rdi
callq 0x26e6
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x3458
movq %rax, %rdi
movq %r15, %rsi
callq 0x3796
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3086
movq (%r15), %r14
testq %rax, %rax
jne 0x2a74
leaq -0x1c(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x30f6
movq %r14, (%rax)
leaq 0xa8(%rbx), %rdi
movq %r15, %rsi
callq 0x38b8
movl (%rax), %eax
movq -0x28(%rbp), %rcx
movl %eax, 0x20(%rcx)
addq $0xe0, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38b8
movl (%rax), %eax
movq -0x28(%rbp), %r14
movl %eax, 0x24(%r14)
movq %r14, %rdi
callq 0x2608
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::remove_node(int, node*)
void EulerTourTree::remove_node(int u, node * nn) {
    int n0 = nn->adjacent_nodes[0];
    int n1 = nn->adjacent_nodes[1];
    NodeSet[u].erase(nn);
    if(NodeSet[u].empty())
        IDtoNode.erase(u);
    else {
        node * next = *NodeSet[u].begin();
        IDtoNode[u] = next;
        BinarySearchTree::change_root(next);
        next->adjacent_nodes[0] = n0;
        next->adjacent_nodes[1] = n1;
        next->update();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x2c(%rbp), %r15
movl %esi, (%r15)
leaq -0x40(%rbp), %r12
movq %rdx, (%r12)
movl 0x20(%rdx), %eax
movl %eax, -0x34(%rbp)
movl 0x24(%rdx), %eax
movl %eax, -0x30(%rbp)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3458
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x3de4
movq %r13, %rdi
movq %rax, %rsi
callq 0x3e6c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3458
cmpq $0x0, 0x28(%rax)
je 0x2b5e
movq %r14, %rdi
movq %r15, %rsi
callq 0x3458
movq 0x18(%rax), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x30f6
movq %r14, (%rax)
movq %r14, %rdi
callq 0x26e6
movl -0x34(%rbp), %eax
movl %eax, 0x20(%r14)
movl -0x30(%rbp), %eax
movl %eax, 0x24(%r14)
movq %r14, %rdi
callq 0x2608
jmp 0x2b6a
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x3f26
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::re_root(node*)
void EulerTourTree::re_root(node * nn) {
    BinarySearchTree::change_root(nn);
    
    if(!nn->left) //nn already in front of the tree
        return;

    node * l = nn->left;
    BinarySearchTree::remove_child(l);
    node * front = BinarySearchTree::leftmost(l);
    front->left = nn;
    nn->par = front;
    front->update();
    BinarySearchTree::change_root(nn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x26e6
movq (%rbx), %r14
testq %r14, %r14
je 0x2be7
movq %r14, %rdi
callq 0x27fe
movq %r14, %rdi
callq 0x28e6
movq %rbx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x2608
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x26e6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::link(int, int)
bool EulerTourTree::link(int u, int v) {
    if(is_connected(u,v))
        return false;
    node * x = get_node(u);
    node * y = get_node(v);
    if(x)
        re_root(x);
    if(y)
        re_root(y);
    node * utemp = BinarySearchTree::insert_new(x);
   // cout << "ok,y=" << v << endl;
    node * vtemp = BinarySearchTree::insert_new(y);
    utemp->value = u;
    vtemp->value = v;
    add_node(u, utemp);
    add_node(v, vtemp);
    if(!y)
        y = vtemp;
    BinarySearchTree::change_root(y);
    utemp->right = y;
    y->par = utemp;
    utemp->update();

    add_edge(u, v, utemp);
    add_edge(v, u, vtemp);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0x2cfa
testb %al, %al
jne 0x2ce8
movb %al, -0x29(%rbp)
movq %r14, %rdi
movl %r12d, -0x30(%rbp)
movl %r12d, %esi
callq 0x2974
movq %rax, %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x2974
movq %rax, %r13
testq %r12, %r12
je 0x2c43
movq %r12, %rsi
callq 0x2ba2
testq %r13, %r13
je 0x2c50
movq %r13, %rsi
callq 0x2ba2
movq %r12, %rdi
callq 0x2660
movq %rax, %r12
movq %r13, %rdi
callq 0x2660
movq %rax, %rbx
movl -0x30(%rbp), %esi
movl %esi, 0x18(%r12)
movl %r15d, 0x18(%rax)
movq %r14, %rdi
movq %r12, %rdx
callq 0x29de
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x29de
testq %r13, %r13
cmoveq %rbx, %r13
movq %r13, %rdi
callq 0x26e6
movq %r13, 0x8(%r12)
movq %r12, 0x10(%r13)
movq %r12, %rdi
callq 0x2608
shlq $0x20, %r15
movl -0x30(%rbp), %r13d
orq %r15, %r13
leaq -0x38(%rbp), %r15
movq %r13, (%r15)
addq $0x70, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b5a
movq %r12, (%rax)
rolq $0x20, %r13
movq %r13, (%r15)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x3b5a
movq %rbx, (%rax)
movb -0x29(%rbp), %al
xorb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::is_connected(int, int)
bool EulerTourTree::is_connected(int u, int v) {
    if(u == v)
        return true;
    node * x = get_node(u);
    node * y = get_node(v);
    if(!x || !y)
        return false;

    BinarySearchTree::change_root(x);
    BinarySearchTree::change_root(y);

    while(x->par && x->par!=y)
        BinarySearchTree::rotate(x);

    return x->par == y;

}

// Assembly:
movb $0x1, %al
cmpl %edx, %esi
je 0x2d88
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %r15
callq 0x2974
movq %rax, %rbx
movq %r15, %rdi
movl %r14d, %esi
callq 0x2974
movq %rax, %r14
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x2d7c
movq %rbx, %rdi
callq 0x26e6
movq %r14, %rdi
callq 0x26e6
movq 0x10(%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %al
orb %al, %cl
jne 0x2d7e
movq %rbx, %rdi
callq 0x27de
movq 0x10(%rbx), %rcx
cmpq %r14, %rcx
sete %al
testq %rcx, %rcx
je 0x2d7e
cmpq %r14, %rcx
jne 0x2d5e
jmp 0x2d7e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::cut(int, int)
bool EulerTourTree::cut(int u, int v) {
    node * x = get_edge(u, v);
    if(!x)
        return false;

    node * y = get_edge(v, u);
    re_root(x);
    BinarySearchTree::change_root(y);
    while(x->par != y)
        BinarySearchTree::rotate(x);
    BinarySearchTree::remove_child(x);

    node * next = BinarySearchTree::next_in_seq(y);
    if(next) {
        int temp = next->value;
        node * t = BinarySearchTree::rightmost(next);
        remove_edge(v,temp);
        add_edge(v, temp, t);
    }

    remove_node(u, x);
    remove_node(v, y);
    remove_edge(u, v);
    remove_edge(v, u);
    BinarySearchTree::delete_node(x);
    BinarySearchTree::delete_node(y);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %edx, -0x38(%rbp)
movl %edx, %r12d
movq %r12, %rax
shlq $0x20, %rax
movl %esi, %r13d
orq %rax, %r13
leaq -0x30(%rbp), %rsi
movq %r13, (%rsi)
leaq 0x70(%rdi), %rbx
movq %rbx, %rdi
callq 0x33b2
testq %rax, %rax
je 0x2e02
movq %r12, -0x58(%rbp)
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x2e02
movq %r14, -0x50(%rbp)
movq %r13, %rax
rolq $0x20, %rax
leaq -0x30(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x33b2
testq %rax, %rax
je 0x2e09
movq 0x10(%rax), %r14
jmp 0x2e0c
xorl %eax, %eax
jmp 0x2ede
xorl %r14d, %r14d
movq %r12, %rsi
callq 0x2ba2
movq %r14, %rdi
callq 0x26e6
cmpq %r14, 0x10(%r12)
je 0x2e2d
movq %r12, %rdi
callq 0x27de
jmp 0x2e1c
movl %r15d, -0x34(%rbp)
movq %r12, %rdi
callq 0x27fe
movq %r14, %rdi
callq 0x2910
testq %rax, %rax
je 0x2e87
movl 0x18(%rax), %r15d
movq %rax, %rdi
callq 0x2948
movq %rax, -0x40(%rbp)
shlq $0x20, %r15
addq -0x58(%rbp), %r15
leaq -0x30(%rbp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x401a
leaq -0x30(%rbp), %rax
movq %r15, (%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b5a
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %r15
movq %r15, %rdi
movl -0x34(%rbp), %esi
movq %r12, %rdx
callq 0x2ab4
movq %r15, %rdi
movl -0x38(%rbp), %esi
movq %r14, %rdx
callq 0x2ab4
leaq -0x30(%rbp), %r15
movq %r13, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x401a
movq -0x48(%rbp), %rax
movq %rax, (%r15)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x401a
movq %r12, %rdi
callq 0x2828
movq %r14, %rdi
callq 0x2828
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::size(int)
int EulerTourTree::size(int u) {
    node * x = get_node(u);
    if(!x)
        return 1;
    BinarySearchTree::change_root(x);
    return x->size/2 + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x2974
testq %rax, %rax
je 0x2f19
movq %rax, %rbx
movq %rax, %rdi
callq 0x26e6
movl 0x1c(%rbx), %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
incl %eax
jmp 0x2f1e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::get_adjacent(int, bool)
int EulerTourTree::get_adjacent(int u, bool is_treeedge) {
    node * x = get_node(u);
    if(!x)
        return adj_map[is_treeedge][u] > 0 ? u : -1;
    BinarySearchTree::change_root(x);
    if(x->sum_adjacent_nodes[is_treeedge] <= 0)
        return -1;
    while(adj_map[is_treeedge][x->value] == 0) {
        node * l = x->left;
        node * r = x->right;
        if(l && l->sum_adjacent_nodes[is_treeedge] > 0)
            x = l;
        else if(r && r->sum_adjacent_nodes[is_treeedge] > 0)
            x = r;
    }

    BinarySearchTree::change_root(x);
    return x->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rdi, %r14
movl %esi, -0x24(%rbp)
callq 0x2974
testq %rax, %rax
je 0x2fdc
movq %rax, %rbx
movq %rax, %rdi
callq 0x26e6
movzbl %r15b, %r12d
cmpl $0x0, 0x28(%rbx,%r12,4)
jle 0x3007
imulq $0x38, %r12, %rax
addq %rax, %r14
addq $0xa8, %r14
movq %rbx, %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x38b8
cmpl $0x0, (%rax)
je 0x2f8e
movq %rbx, %r15
jmp 0x2fce
movq (%rbx), %r15
movq 0x8(%rbx), %rax
testq %r15, %r15
je 0x2fa2
cmpl $0x0, 0x28(%r15,%r12,4)
jg 0x2fba
testq %rax, %rax
je 0x2fb7
cmpl $0x0, 0x28(%rax,%r12,4)
jg 0x2fb2
movq %rbx, %rax
movq %rax, %r15
jmp 0x2fba
movq %rbx, %r15
leaq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x38b8
cmpl $0x0, (%rax)
movq %r15, %rbx
je 0x2f8e
movq %r15, %rdi
callq 0x26e6
movl 0x18(%r15), %eax
jmp 0x300c
movzbl %r15b, %eax
imulq $0x38, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xa8, %rdi
leaq -0x24(%rbp), %rsi
callq 0x38b8
cmpl $0x0, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jle 0x300c
movl -0x24(%rbp), %eax
jmp 0x300c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/EulerTourTree.cpp
// Function: EulerTourTree::update_adjacent(int, int, bool)
void EulerTourTree::update_adjacent(int u, int add_adj, bool is_treeedge) {
    adj_map[is_treeedge][u] += add_adj;
    node * x = get_node(u);
    if(!x)
        return;
    BinarySearchTree::change_root(x);
    x->adjacent_nodes[is_treeedge] += add_adj;
    x->update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x24(%rbp), %r15
movl %esi, (%r15)
movl %ecx, %r12d
imulq $0x38, %r12, %rax
addq %rax, %rdi
addq $0xa8, %rdi
movq %r15, %rsi
callq 0x38b8
addl %ebx, (%rax)
movl (%r15), %esi
movq %r14, %rdi
callq 0x2974
testq %rax, %rax
je 0x3078
movq %rax, %r14
movq %rax, %rdi
callq 0x26e6
addl %ebx, 0x20(%r14,%r12,4)
movq %r14, %rdi
callq 0x2608
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::add_vertex(int)
void connectivity::add_vertex(int u) {
	vertices.insert(u);
	spf.push_back(EulerTourTree());
	adj.push_back(unordered_map<int, unordered_multiset<int> >());
	treeadj.push_back(unordered_map<int, unordered_multiset<int> >());
	//cout << "OK tested add_vertex" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq -0x2c(%rbp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x4e12
leaq -0x128(%rbp), %rdi
movl $0xf8, %edx
xorl %esi, %esi
callq 0x20d0
leaq -0x118(%rbp), %r12
movq %r12, -0x30(%r12)
movl $0x1, %eax
movq %rax, -0x28(%r12)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r12)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, -0x10(%r12)
movups %xmm0, -0x8(%r12)
leaq -0x110(%rbp), %r14
leaq -0xe0(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
leaq -0xd8(%rbp), %r15
leaq -0xa8(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
movl $0x70, %eax
leaq -0x70(%rbp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
addq $0x38, %rcx
addq $-0x38, %rax
jne 0x41ba
leaq 0x30(%rbx), %rdi
leaq -0x148(%rbp), %rsi
callq 0x4f2e
movl $0xe0, %r13d
leaq -0x148(,%r13), %rdi
addq %rbp, %rdi
callq 0x4b0e
addq $-0x38, %r13
cmpq $0x70, %r13
jne 0x41f5
movq %r15, %rdi
callq 0x4b84
movq %r14, %rdi
callq 0x4bfa
leaq -0x148(%rbp), %r14
movq %r14, %rdi
callq 0x4c90
leaq 0x48(%rbx), %rdi
movq $0x0, 0x20(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x148(%rbp), %rsi
callq 0x53c2
movq %r14, %rdi
callq 0x4d06
addq $0x60, %rbx
movq $0x0, 0x20(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x148(%rbp), %rsi
movq %rbx, %rdi
callq 0x53c2
leaq -0x148(%rbp), %rdi
callq 0x4d06
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42c9
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x4d06
jmp 0x42e9
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x4acc
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::add_edge_level(int, int, int, bool)
void connectivity::add_edge_level(int u, int v, int level, bool is_treeedge) {
	if(u > v)
		swap(u, v);
	edge_level[make_pair(u,v)].insert(level);

	if(is_treeedge){
		treeadj[level][u].insert(v);
		treeadj[level][v].insert(u);
	}
	else {
		adj[level][u].insert(v);
		adj[level][v].insert(u);
	}

	spf[level].update_adjacent(u, 1, is_treeedge);
	spf[level].update_adjacent(v, 1, is_treeedge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rdi, %rbx
movl %esi, -0x34(%rbp)
movl %edx, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
cmpl %edx, %esi
jle 0x4320
movl %edx, -0x34(%rbp)
movl %esi, -0x30(%rbp)
movl %esi, %eax
jmp 0x4324
movl %edx, %eax
movl %esi, %edx
leaq 0x78(%rbx), %rdi
shlq $0x20, %rax
movl %edx, %ecx
orq %rax, %rcx
leaq -0x40(%rbp), %rsi
movq %rcx, (%rsi)
callq 0x5612
leaq -0x2c(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x59a2
movslq (%r15), %rax
imulq $0x38, %rax, %rdi
testb %r14b, %r14b
je 0x4392
addq 0x60(%rbx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x59e8
leaq -0x40(%rbp), %r12
movq %rax, (%r12)
leaq -0x30(%rbp), %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5cd8
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq 0x60(%rbx), %rdi
jmp 0x43ca
addq 0x48(%rbx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x59e8
leaq -0x40(%rbp), %r12
movq %rax, (%r12)
leaq -0x30(%rbp), %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5cd8
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq 0x48(%rbx), %rdi
movq %r13, %rsi
callq 0x59e8
movq %rax, (%r12)
leaq -0x40(%rbp), %rcx
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x5cd8
movslq -0x2c(%rbp), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl -0x34(%rbp), %esi
movzbl %r14b, %r14d
movl $0x1, %edx
movl %r14d, %ecx
callq 0x301a
movslq -0x2c(%rbp), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl -0x30(%rbp), %esi
movl $0x1, %edx
movl %r14d, %ecx
callq 0x301a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::remove_edge_level(int, int, int, bool)
void connectivity::remove_edge_level(int u, int v, int level, bool is_treeedge) {
	if(u > v)
		swap(u, v);
	pair <int ,int> p = make_pair(u, v);
	edge_level[p].erase(edge_level[p].find(level));

	if(is_treeedge) {
		treeadj[level][u].erase(treeadj[level][u].find(v));
		treeadj[level][v].erase(treeadj[level][v].find(u));
	}
	else {
		adj[level][u].erase(adj[level][u].find(v));
		adj[level][v].erase(adj[level][v].find(u));
	}

	spf[level].update_adjacent(u, -1, is_treeedge);
	spf[level].update_adjacent(v, -1, is_treeedge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
movl %edx, -0x34(%rbp)
cmpl %edx, %esi
movl %r8d, -0x30(%rbp)
jle 0x4467
movl %edx, -0x2c(%rbp)
movl %esi, -0x34(%rbp)
movl %esi, %eax
jmp 0x446b
movl %edx, %eax
movl %esi, %edx
shlq $0x20, %rax
movl %edx, %ecx
orq %rax, %rcx
leaq -0x48(%rbp), %r13
movq %rcx, (%r13)
leaq 0x78(%rbx), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x6026
movq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x6026
movq 0x10(%rax), %rcx
addq $0x8, %rax
testq %rcx, %rcx
je 0x44ce
movq %rax, %rdx
xorl %esi, %esi
cmpl %r15d, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x44a9
cmpq %rax, %rdx
je 0x44ce
cmpl %r15d, 0x20(%rdx)
cmovleq %rdx, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x60e4
movq %rbx, %r12
addq $0x48, %rbx
leaq 0x60(%r12), %rax
cmpb $0x0, -0x30(%rbp)
cmovneq %rax, %rbx
movslq %r15d, %rax
movq %rax, -0x40(%rbp)
imulq $0x38, %rax, %r13
movq (%rbx), %rdi
addq %r13, %rdi
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x59e8
movq %rax, %r14
movq (%rbx), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x59e8
leaq -0x34(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6126
movq %r14, %rdi
movq %rax, %rsi
callq 0x6188
movq (%rbx), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x59e8
movq %rax, %r14
addq (%rbx), %r13
movq %r13, %rdi
movq %r15, %r13
movq %r15, %rsi
callq 0x59e8
movq %rax, %rdi
leaq -0x2c(%rbp), %rbx
movq %rbx, %rsi
callq 0x6126
movq %r14, %rdi
movq %rax, %rsi
callq 0x6188
imulq $0x118, -0x40(%rbp), %r14 # imm = 0x118
movq 0x30(%r12), %rdi
addq %r14, %rdi
movl (%rbx), %esi
movzbl -0x30(%rbp), %r15d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r15d, %ecx
callq 0x301a
addq 0x30(%r12), %r14
movl (%r13), %esi
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r15d, %ecx
callq 0x301a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::level(int, int)
int connectivity::level(int u, int v) {
	if(u > v)
		swap(u, v);
	auto it = edge_level.find(make_pair(u,v));
	if(it == edge_level.end())
		return -1;
	return *it->second.rbegin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl %edx, %esi
movl %edx, %eax
cmovgl %esi, %eax
cmovll %esi, %edx
addq $0x78, %rdi
shlq $0x20, %rax
orq %rax, %rdx
leaq -0x8(%rbp), %rsi
movq %rdx, (%rsi)
callq 0x6240
testq %rax, %rax
je 0x45fd
addq $0x18, %rax
movq %rax, %rdi
callq 0x20f0
movl 0x20(%rax), %eax
jmp 0x4602
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::is_connected(int, int)
bool connectivity::is_connected(int u, int v) {
	if(!vertices.count(u) || !vertices.count(v))
		return false;
	if(u == v)
		return true;
	return spf[0].is_connected(u, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x4ab7
leaq 0x8(%rdi), %rcx
movq %rax, %r9
movq %rcx, %r8
xorl %r10d, %r10d
cmpl %esi, 0x20(%r9)
setl %r10b
cmovgeq %r9, %r8
movq 0x10(%r9,%r10,8), %r9
testq %r9, %r9
jne 0x4a6d
cmpq %rcx, %r8
je 0x4ab7
cmpl %esi, 0x20(%r8)
jg 0x4ab7
movq %rcx, %r8
xorl %r9d, %r9d
cmpl %edx, 0x20(%rax)
setl %r9b
cmovgeq %rax, %r8
movq 0x10(%rax,%r9,8), %rax
testq %rax, %rax
jne 0x4a94
cmpq %rcx, %r8
je 0x4ab7
cmpl %edx, 0x20(%r8)
jle 0x4abb
xorl %eax, %eax
popq %rbp
retq
movb $0x1, %al
cmpl %edx, %esi
je 0x4ab9
movq 0x30(%rdi), %rdi
popq %rbp
jmp 0x2cfa
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::add_vertex(int)
void MST::add_vertex(int u) {
	vertices.insert(u);
	min_spf.push_back(EulerTourTree());
	adj.push_back(unordered_map<int, multiset<pair<int,int>>>());
	treeadj.push_back(unordered_map<int, multiset<pair<int,int>>>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq -0x2c(%rbp), %rax
movl %esi, (%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x4e12
leaq -0x128(%rbp), %rdi
movl $0xf8, %edx
xorl %esi, %esi
callq 0x20d0
leaq -0x118(%rbp), %r12
movq %r12, -0x30(%r12)
movl $0x1, %eax
movq %rax, -0x28(%r12)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r12)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, -0x10(%r12)
movups %xmm0, -0x8(%r12)
leaq -0x110(%rbp), %r14
leaq -0xe0(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
leaq -0xd8(%rbp), %r15
leaq -0xa8(%rbp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
movl $0x70, %eax
leaq -0x70(%rbp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
addq $0x38, %rcx
addq $-0x38, %rax
jne 0x6336
leaq 0x68(%rbx), %rdi
leaq -0x148(%rbp), %rsi
callq 0x4f2e
movl $0xe0, %r13d
leaq -0x148(,%r13), %rdi
addq %rbp, %rdi
callq 0x4b0e
addq $-0x38, %r13
cmpq $0x70, %r13
jne 0x6371
movq %r15, %rdi
callq 0x4b84
movq %r14, %rdi
callq 0x4bfa
leaq -0x148(%rbp), %r14
movq %r14, %rdi
callq 0x4c90
leaq 0xb8(%rbx), %rdi
movq $0x0, 0x20(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x148(%rbp), %rsi
callq 0x758c
movq %r14, %rdi
callq 0x7446
addq $0xd0, %rbx
movq $0x0, 0x20(%r14)
movq %r12, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x148(%rbp), %rsi
movq %rbx, %rdi
callq 0x758c
leaq -0x148(%rbp), %rdi
callq 0x7446
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x644b
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x7446
jmp 0x646b
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x4acc
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::add_edge(int, int, int)
bool MST::add_edge(int u, int v, int wt) {
	if(!vertices.count(u) || !vertices.count(v)) {
        return false;
    }

    adj_list[u].push_back(make_pair(v,wt));
	adj_list[v].push_back(make_pair(u,wt));
    weight[make_pair(u,v)] = wt;
	weight[make_pair(v,u)] = wt;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x69f0
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
leaq 0x40(%rdi), %rcx
movq %rax, %rdi
movq %rcx, %rdx
xorl %r8d, %r8d
cmpl %esi, 0x20(%rdi)
setl %r8b
cmovgeq %rdi, %rdx
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x69a8
cmpq %rcx, %rdx
je 0x69f0
cmpl %esi, 0x20(%rdx)
jg 0x69f0
movq %rcx, %rdx
xorl %esi, %esi
cmpl %r15d, 0x20(%rax)
setl %sil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x69cd
cmpq %rcx, %rdx
je 0x69f0
cmpl %r15d, 0x20(%rdx)
jle 0x6a01
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80(%r14), %r12
leaq -0x2c(%rbp), %rsi
movq %r12, %rdi
callq 0x7f46
movq %rbx, %r13
shlq $0x20, %r13
movl %r15d, %ecx
orq %r13, %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6a39
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x6a45
leaq -0x38(%rbp), %rdx
movq %rax, %rdi
callq 0x8236
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
callq 0x7f46
movl -0x2c(%rbp), %ecx
orq %rcx, %r13
movq %r13, -0x38(%rbp)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6a6f
movq %r13, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x6a7e
leaq -0x38(%rbp), %rdx
movq %rax, %rdi
callq 0x8236
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %eax
shlq $0x20, %rax
orq %rcx, %rax
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7ac2
movl %ebx, (%rax)
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%r15)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x7ac2
movl %ebx, (%rax)
movb $0x1, %al
jmp 0x69f2
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/MST.cpp
// Function: MST::find_MST()
set <pair<pair<int,int>,int>> MST::find_MST()  {
	set <pair<pair<int,int>,int>> res;
	treeadj[0].erase(-1);
	for(auto &i:treeadj[0]) {
		for(auto &k:i.second) {
			res.insert(make_pair(make_pair(i.first,k.second),k.first));
		}
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0xd0(%rsi), %rdi
leaq -0x38(%rbp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
callq 0x8372
movq 0xd0(%r14), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x6f14
leaq -0x38(%rbp), %r14
movq 0x28(%r12), %r15
leaq 0x18(%r12), %r13
cmpq %r13, %r15
je 0x6f0b
movl 0x8(%r12), %eax
movl 0x20(%r15), %ecx
movl 0x24(%r15), %edx
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, -0x38(%rbp)
movl %ecx, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x847c
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
cmpq %r13, %rax
jne 0x6ed5
movq (%r12), %r12
testq %r12, %r12
jne 0x6ec6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f28
movq %rax, %r14
movq %rbx, %rdi
callq 0x7534
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/SPT.cpp
// Function: SPT::add_edge(int, int, int)
bool SPT::add_edge(int u, int v, int wt) {
    if(!vertices.count(u) || !vertices.count(v)) {
        return false;
    }

    adj[u].push_back(v);
    revadj[v].push_back(u);
    weight[make_pair(u,v)] = wt;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x20(%rbp)
movl %edx, -0x1c(%rbp)
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x88f2
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
leaq 0x48(%rdi), %rcx
movq %rax, %rdi
movq %rcx, %rdx
xorl %r8d, %r8d
cmpl %esi, 0x20(%rdi)
setl %r8b
cmovgeq %rdi, %rdx
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x88aa
cmpq %rcx, %rdx
je 0x88f2
cmpl %esi, 0x20(%rdx)
jg 0x88f2
movq %rcx, %rdx
xorl %esi, %esi
cmpl %r15d, 0x20(%rax)
setl %sil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x88cf
cmpq %rcx, %rdx
je 0x88f2
cmpl %r15d, 0x20(%rdx)
jle 0x88ff
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x70(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9d62
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8923
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x892f
leaq -0x1c(%rbp), %rdx
movq %rax, %rdi
callq 0xa052
leaq 0xa8(%r14), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x9d62
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x8958
movl -0x20(%rbp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x896a
leaq -0x20(%rbp), %r15
movq %rax, %rdi
movq %r15, %rdx
callq 0xa052
movl (%r15), %ecx
addq $0x8, %r14
movl -0x1c(%rbp), %eax
shlq $0x20, %rax
movl %ecx, %ecx
orq %rax, %rcx
leaq -0x28(%rbp), %rsi
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x7ac2
movl %ebx, (%rax)
movb $0x1, %al
jmp 0x88f4
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/SPT.cpp
// Function: SPT::build_static_SPT()
void SPT::build_static_SPT() {

    dist.resize(vertices.size());
    fill(dist.begin(),dist.end(),INF);
    spt.resize(vertices.size());
    fill(spt.begin(),spt.end(),make_pair(-1,-1));
    priority_queue<pair<int,int>, vector <pair<int,int>> , greater<pair<int,int>> > pq; 
    pq.push(make_pair(0, source)); 
    dist[source] = 0; 
    spt[source] = make_pair(-1,-1);
  
    while (!pq.empty()) 
    {
        int u = pq.top().second; 
        pq.pop(); 
  
        for (auto &v : adj[u]) 
        {
            int wt = weight[make_pair(u,v)]; 
  
            if (dist[v] > dist[u] + wt) 
            {
                dist[v] = dist[u] + wt;
                spt[v] = make_pair(u,wt);
                pq.push(make_pair(dist[v], v));
            }
        } 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xf8(%rdi), %r14
movq 0x68(%rdi), %rsi
movq %r14, %rdi
callq 0x9c1a
movq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
cmpq %rdx, %rdi
je 0x89e5
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0x3f, %esi
callq 0x20d0
leaq 0xe0(%rbx), %rdi
movq 0x68(%rbx), %rsi
movq %rdi, -0x70(%rbp)
callq 0x9c52
movq 0xe0(%rbx), %rdi
movq 0xe8(%rbx), %rdx
cmpq %rdx, %rdi
je 0x8a25
subq %rdi, %rdx
addq $-0x8, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
movl $0xff, %esi
callq 0x20d0
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rbx), %eax
shlq $0x20, %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
callq 0x7358
movslq (%rbx), %rax
movq 0xf8(%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
movslq (%rbx), %rax
movq 0xe0(%rbx), %rcx
movq $-0x1, (%rcx,%rax,8)
movq -0x60(%rbp), %rdi
cmpq -0x58(%rbp), %rdi
je 0x8b30
leaq 0x70(%rbx), %rax
movq %rax, -0x68(%rbp)
addq $0x8, %rbx
leaq -0x38(%rbp), %r12
movl 0x4(%rdi), %eax
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x73f6
movq -0x68(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x9d62
movq (%rax), %r13
movq 0x8(%rax), %r15
cmpq %r15, %r13
je 0x8b22
movl -0x2c(%rbp), %eax
movl (%r13), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7ac2
movl (%rax), %eax
movslq (%r13), %rdx
movq (%r14), %rcx
movslq -0x2c(%rbp), %rsi
movl (%rcx,%rsi,4), %esi
addl %eax, %esi
cmpl %esi, (%rcx,%rdx,4)
jle 0x8b1c
movl %esi, (%rcx,%rdx,4)
movl -0x2c(%rbp), %edx
movslq (%r13), %rsi
movq -0x70(%rbp), %rdi
movq (%rdi), %rdi
movl %edx, (%rdi,%rsi,8)
movl %eax, 0x4(%rdi,%rsi,8)
movslq (%r13), %rax
movl (%rcx,%rax,4), %ecx
shlq $0x20, %rax
orq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
movq %r12, %rsi
callq 0x7358
addq $0x4, %r13
jmp 0x8aad
movq -0x60(%rbp), %rdi
cmpq -0x58(%rbp), %rdi
jne 0x8a8a
testq %rdi, %rdi
je 0x8b3a
callq 0x2170
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b51
jmp 0x8b51
jmp 0x8b51
jmp 0x8b51
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x8b62
callq 0x2170
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/SPT.cpp
// Function: SPT::change_weight(int, int, int)
bool SPT::change_weight(int u,int v, int newwt) {
    if(!vertices.count(u) || !vertices.count(v) || weight.find(make_pair(u,v)) == weight.end()) {
        return false;
    }
    
    int oldwt = weight[make_pair(u,v)];
    weight[make_pair(u,v)] = newwt;
    
    if(newwt > oldwt && spt[v].first == u) {
        int diff = newwt - oldwt;
        modify_inc(u,v,oldwt,diff);
        return true;
    }

    else if(newwt < oldwt && dist[u] + newwt < dist[v]) {
        int diff = dist[u] + newwt - dist[v];
        modify_dec(u,v,oldwt,diff);
        return true;
    }
    return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x8c6f
movl %ecx, %r14d
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r15
leaq 0x48(%rdi), %rcx
movq %rax, %rsi
movq %rcx, %rdx
xorl %edi, %edi
cmpl %r12d, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x8b9d
cmpq %rcx, %rdx
je 0x8c6f
cmpl %r12d, 0x20(%rdx)
jg 0x8c6f
movq %rcx, %rdx
xorl %esi, %esi
cmpl %ebx, 0x20(%rax)
setl %sil
cmovgeq %rax, %rdx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x8bcb
cmpq %rcx, %rdx
je 0x8c6f
cmpl %ebx, 0x20(%rdx)
jg 0x8c6f
leaq 0x8(%r15), %rdi
movq %rbx, %rax
shlq $0x20, %rax
movl %r12d, %r13d
orq %rax, %r13
leaq -0x30(%rbp), %rsi
movq %r13, (%rsi)
movq %rdi, -0x40(%rbp)
callq 0xa372
testq %rax, %rax
je 0x8c6f
leaq -0x30(%rbp), %rsi
movq %r13, (%rsi)
movq -0x40(%rbp), %rdi
callq 0x7ac2
movl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movq %r13, (%rax)
leaq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x7ac2
movl -0x34(%rbp), %edx
movl %r14d, (%rax)
movl %r14d, %r8d
subl %edx, %r8d
jle 0x8c84
movslq %ebx, %rax
movq 0xe0(%r15), %rcx
cmpl %r12d, (%rcx,%rax,8)
jne 0x8c84
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
callq 0x8cb2
movb $0x1, %r13b
jmp 0x8c72
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r13b
cmpl %edx, %r14d
jge 0x8c72
movslq %r12d, %rax
movq 0xf8(%r15), %rcx
addl (%rcx,%rax,4), %r14d
movslq %ebx, %rax
subl (%rcx,%rax,4), %r14d
jge 0x8c72
movq %r15, %rdi
movl %ebx, %edx
movl %r14d, %r8d
callq 0x955a
jmp 0x8c72
// File: /workspace/github_cpp_makefile_star2_O3/yogesh1q2w[P]Dynamic-Graph-Algorithms/main.cpp
// Function: main
int main() {
	srand(0);
	int ch = 1;
	string st;
	while(ch != 0) {
		cout << "Enter choice -\n1- Fully dynamic connectivity\n2- Decremental MST\n3- Fully dynamic SPT\nand file name to run on:" << endl;
		cin >> ch >> st;
		test(ch,st);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %edi, %edi
callq 0x2180
leaq -0x2c(%rbp), %rax
movl $0x1, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x60(%rbp), %r12
movq 0x5afe(%rip), %r14      # 0x10fd0
leaq -0x50(%rbp), %r13
leaq -0x70(%rbp), %rbx
movl $0x6d, %edx
movq %r14, %rdi
leaq 0xbbe(%rip), %rsi       # 0xc0a7
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq 0x5ac4(%rip), %rdi      # 0x10fe0
leaq -0x2c(%rbp), %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x21f0
movl -0x2c(%rbp), %r15d
movq %r12, -0x70(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xba2c
movl %r15d, %edi
movq %rbx, %rsi
callq 0xa9ac
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0xb564
callq 0x2170
cmpl $0x0, -0x2c(%rbp)
jne 0xb4da
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xb580
callq 0x2170
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0xb5a7
callq 0x2170
jmp 0xb5a7
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xb5b9
callq 0x2170
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/main.cpp
// Function: currentTime[abi:cxx11]()
inline string currentTime() {
	time_t now = time(0);
    struct tm tstruct;
    char buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%R", &tstruct);
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3240
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x31a0
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x60(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x4018(%rip), %rdx      # 0x10588
leaq 0x10(%rsp), %r14
movl $0x50, %esi
movq %r14, %rdi
callq 0x31c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x3100
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2b2
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq