LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
callq 0x2572
movq (%r14), %rbx
movq 0x8(%r14), %r14
movq %rbx, %rax
orq %r14, %rax
je 0x2705
testq %rbx, %rbx
je 0x270a
movq %rbx, %rdi
callq 0x268c
testq %r14, %r14
je 0x2705
movq %r14, %rdi
callq 0x268c
movq %r14, %rdi
callq 0x2716
movq %rbx, (%rax)
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2498
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x268c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2572
movq %rbx, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2725
movq %r14, %rdi
callq 0x2572
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2572
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x276c
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x2757
movq %rbx, %rdi
callq 0x2572
jmp 0x276e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2572
movq %rbx, %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2787
movq %r14, %rdi
callq 0x2572
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3212
testq %rax, %rax
je 0x2806
movq 0x10(%rax), %rax
jmp 0x2808
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2572
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x32bc
movq %rax, %rdi
movq %r15, %rsi
callq 0x36ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2df0
movq (%r15), %r14
testq %rax, %rax
jne 0x28a4
leaq -0x1c(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e9e
movq %r14, (%rax)
leaq 0xa8(%rbx), %rdi
movq %r15, %rsi
callq 0x3880
movl (%rax), %eax
movq -0x28(%rbp), %rcx
movl %eax, 0x20(%rcx)
addq $0xe0, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3880
movl (%rax), %eax
movq -0x28(%rbp), %r14
movl %eax, 0x24(%r14)
movq %r14, %rdi
callq 0x2498
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x38(%rbp), %r12
movq %rdx, (%r12)
movl 0x20(%rdx), %r13d
movl 0x24(%rdx), %eax
movl %eax, -0x30(%rbp)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x32bc
movq %rax, %rdi
movq %r12, %rsi
callq 0x3f5a
movq %r14, %rdi
movq %r15, %rsi
callq 0x32bc
cmpq $0x0, 0x28(%rax)
je 0x297b
movq %r14, %rdi
movq %r15, %rsi
callq 0x32bc
movq 0x18(%rax), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e9e
movq %r14, (%rax)
movq %r14, %rdi
callq 0x2572
movl %r13d, 0x20(%r14)
movl -0x30(%rbp), %eax
movl %eax, 0x24(%r14)
movq %r14, %rdi
callq 0x2498
jmp 0x2987
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x4126
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2572
movq (%rbx), %r14
testq %r14, %r14
je 0x2a03
movq %r14, %rdi
callq 0x268c
movq %r14, %rdi
callq 0x2716
movq %rbx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x2498
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2572
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %esi, %ebx
movq %rdi, %r12
callq 0x2b0a
movl %eax, %r15d
testb %al, %al
jne 0x2af4
movq %r12, %rdi
movl %ebx, -0x30(%rbp)
movl %ebx, %esi
callq 0x27a4
movq %rax, %rbx
movq %r12, %rdi
movl %r14d, %esi
callq 0x27a4
movq %rax, %r13
testq %rbx, %rbx
je 0x2a5c
movq %rbx, %rsi
callq 0x29be
movl %r14d, -0x2c(%rbp)
testq %r13, %r13
je 0x2a6d
movq %r13, %rsi
callq 0x29be
movq %rbx, %rdi
callq 0x24f0
movq %rax, %r14
movq %r13, %rdi
callq 0x24f0
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %esi
movl %esi, 0x18(%r14)
movl -0x2c(%rbp), %ebx
movl %ebx, 0x18(%rax)
movq %r12, %rdi
movq %r14, %rdx
callq 0x280e
movq %r12, %rdi
movl %ebx, %esi
movq -0x38(%rbp), %rbx
movq %rbx, %rdx
callq 0x280e
testq %r13, %r13
cmoveq %rbx, %r13
movq %r13, %rdi
callq 0x2572
movq %r13, 0x8(%r14)
movq %r14, 0x10(%r13)
movq %r14, %rdi
callq 0x2498
movq %r12, %rdi
movl -0x30(%rbp), %ebx
movl %ebx, %esi
movl -0x2c(%rbp), %r13d
movl %r13d, %edx
movq %r14, %rcx
callq 0x28b8
movq %r12, %rdi
movl %r13d, %esi
movl %ebx, %edx
movq -0x38(%rbp), %rcx
callq 0x28b8
xorb $0x1, %r15b
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b80
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %r15
callq 0x27a4
movq %rax, %rbx
movq %r15, %rdi
movl %r14d, %esi
callq 0x27a4
movq %rax, %r14
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x2b74
movq %rbx, %rdi
callq 0x2572
movq %r14, %rdi
callq 0x2572
movq 0x10(%rbx), %rcx
cmpq %r14, %rcx
sete %al
testq %rcx, %rcx
je 0x2b76
cmpq %r14, %rcx
je 0x2b76
movq %rbx, %rdi
callq 0x266c
jmp 0x2b56
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %r12
callq 0x27da
movq %rax, %rbx
testq %rax, %rax
je 0x2c6d
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x27da
movq %rax, %r13
movq %rbx, %rsi
callq 0x29be
movq %r13, %rdi
callq 0x2572
cmpq %r13, 0x10(%rbx)
je 0x2bde
movq %rbx, %rdi
callq 0x266c
jmp 0x2bce
movq %rbx, %rdi
callq 0x268c
movq %r13, %rdi
callq 0x2740
testq %rax, %rax
je 0x2c25
movl 0x18(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movq %rax, %rdi
callq 0x2778
movq %rax, -0x38(%rbp)
movq %r12, %rdi
movl %r15d, %esi
movl -0x2c(%rbp), %edx
callq 0x2996
movq %r12, %rdi
movl %r15d, %esi
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0x28b8
movq %r12, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x28e4
movq %r12, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x28e4
movq %r12, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x2996
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x2996
movq %rbx, %rdi
callq 0x26b6
movq %r13, %rdi
callq 0x26b6
testq %rbx, %rbx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27a4
testq %rax, %rax
je 0x2caa
movq %rax, %rbx
movq %rax, %rdi
callq 0x2572
movl 0x1c(%rbx), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
incl %eax
jmp 0x2cad
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
callq 0x27a4
testq %rax, %rax
je 0x2d4b
movq %rax, %r15
movq %rax, %rdi
callq 0x2572
movzbl %r14b, %r13d
cmpl $0x0, 0x28(%r15,%r13,4)
jle 0x2d71
imulq $0x38, %r13, %rax
leaq (%rbx,%rax), %r14
addq $0xa8, %r14
movq %r15, %rbx
leaq 0x18(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3880
cmpl $0x0, (%rax)
jne 0x2d3e
movq (%rbx), %r15
movq 0x8(%rbx), %rax
testq %r15, %r15
je 0x2d2a
cmpl $0x0, 0x28(%r15,%r13,4)
jg 0x2cff
testq %rax, %rax
je 0x2d06
cmpl $0x0, 0x28(%rax,%r13,4)
cmovgq %rax, %rbx
movq %rbx, %r15
jmp 0x2cff
movq %rbx, %rdi
callq 0x2572
movl 0x18(%rbx), %eax
jmp 0x2d74
movzbl %r14b, %eax
imulq $0x38, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xa8, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3880
cmpl $0x0, (%rax)
jle 0x2d71
movl -0x2c(%rbp), %eax
jmp 0x2d74
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3880
addl %ebx, (%rax)
movl (%r15), %esi
movq %r14, %rdi
callq 0x27a4
testq %rax, %rax
je 0x2de2
movq %rax, %r14
movq %rax, %rdi
callq 0x2572
addl %ebx, 0x20(%r14,%r12,4)
movq %r14, %rdi
callq 0x2498
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq -0x1c(%rbp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x4f4c
leaq 0x30(%rbx), %r14
leaq -0x138(%rbp), %r15
movl $0x118, %edx            # imm = 0x118
movq %r15, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r15, %rdi
callq 0x4ac8
movq %r14, %rdi
movq %r15, %rsi
callq 0x50dc
leaq -0x138(%rbp), %r14
movq %r14, %rdi
callq 0x4b66
andq $0x0, 0x20(%r14)
leaq 0x48(%rbx), %rdi
leaq -0x108(%rbp), %r15
movq %r15, -0x30(%r15)
movq $0x1, -0x28(%r15)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r15)
movl $0x3f800000, -0x10(%r15) # imm = 0x3F800000
movups %xmm0, -0x8(%r15)
leaq -0x138(%rbp), %rsi
callq 0x55f6
movq %r14, %rdi
callq 0x4de6
addq $0x60, %rbx
andq $0x0, 0x20(%r14)
movq %r15, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x138(%rbp), %rsi
movq %rbx, %rdi
callq 0x55f6
leaq -0x138(%rbp), %rdi
callq 0x4de6
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4446
movq %rax, %rbx
leaq -0x138(%rbp), %rdi
callq 0x4de6
jmp 0x4466
movq %rax, %rbx
leaq -0x138(%rbp), %rdi
callq 0x4b66
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12d
movq %rdi, %rbx
movl %esi, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movl %ecx, -0x34(%rbp)
cmpl %edx, %esi
jle 0x449c
movl %edx, -0x30(%rbp)
movl %esi, -0x2c(%rbp)
movl %esi, %eax
jmp 0x44a0
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 0x5892
leaq -0x34(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x5cf6
leaq 0x48(%rbx), %r14
leaq 0x60(%rbx), %rax
testb %r12b, %r12b
cmovneq %rax, %r14
movslq (%r15), %rax
imulq $0x38, %rax, %rdi
addq (%r14), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5d5c
leaq -0x2c(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x6112
movslq (%r15), %rax
imulq $0x38, %rax, %rdi
addq (%r14), %rdi
movq %r13, %rsi
callq 0x5d5c
movq %rax, %rdi
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x6112
movslq (%r15), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl (%r14), %esi
movzbl %r12b, %r14d
pushq $0x1
popq %r13
movl %r13d, %edx
movl %r14d, %ecx
callq 0x2d84
movslq (%r15), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
leaq -0x2c(%rbp), %rax
movl (%rax), %esi
movl %r13d, %edx
movl %r14d, %ecx
callq 0x2d84
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movl %r8d, %r14d
movq %rdi, %rbx
movl %esi, -0x34(%rbp)
movl %edx, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
cmpl %edx, %esi
jle 0x459a
movl %edx, -0x34(%rbp)
movl %esi, -0x30(%rbp)
movl %esi, %eax
jmp 0x459e
movl %edx, %eax
movl %esi, %edx
shlq $0x20, %rax
movl %edx, %ecx
orq %rax, %rcx
leaq -0x40(%rbp), %r15
movq %rcx, (%r15)
leaq 0x78(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6550
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x6550
leaq -0x2c(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x664c
movq %r13, %rdi
movq %rax, %rsi
callq 0x66a4
movslq (%r15), %rax
testb %r14b, %r14b
je 0x4616
leaq 0x60(%rbx), %r13
imulq $0x38, %rax, %rdi
addq 0x60(%rbx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x5d5c
movq %rax, %r12
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq 0x60(%rbx), %rdi
jmp 0x463d
leaq 0x48(%rbx), %r13
imulq $0x38, %rax, %rdi
addq 0x48(%rbx), %rdi
leaq -0x34(%rbp), %r15
movq %r15, %rsi
callq 0x5d5c
movq %rax, %r12
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x5d5c
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x6704
movq %r12, %rdi
movq %rax, %rsi
callq 0x673e
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq (%r13), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x5d5c
movq %rax, %r12
movslq -0x2c(%rbp), %rax
imulq $0x38, %rax, %rdi
addq (%r13), %rdi
movq %r15, %rsi
callq 0x5d5c
leaq -0x34(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x6704
movq %r12, %rdi
movq %rax, %rsi
callq 0x673e
movslq -0x2c(%rbp), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl (%r13), %esi
movzbl %r14b, %r14d
pushq $-0x1
popq %r12
movl %r12d, %edx
movl %r14d, %ecx
callq 0x2d84
movslq -0x2c(%rbp), %rax
imulq $0x118, %rax, %rdi      # imm = 0x118
addq 0x30(%rbx), %rdi
movl (%r15), %esi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x2d84
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6852
testq %rax, %rax
je 0x4737
addq $0x18, %rax
movq %rax, %rdi
callq 0x20f0
movl 0x20(%rax), %eax
jmp 0x473a
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yogesh1q2w[P]Dynamic-Graph-Algorithms/connectivity.cpp
// Function: connectivity::add_edge(int, int)
bool connectivity::add_edge(int u, int v) {
	if(!vertices.count(u) || !vertices.count(v)) {
		//cout<<"F"<<endl;
		return false;		//if u or v are absent in graph
	}
	if(!spf[0].is_connected(u, v)) {
		//cout << u <<"," << v << endl;
		spf[0].link(u, v);
		add_edge_level(u, v, 0, true);
	}
	else
		add_edge_level(u, v, 0, false);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x10(%rbp), %rax
movl %esi, (%rax)
movl %edx, -0xc(%rbp)
movq %rax, %rsi
callq 0x4ba8
testq %rax, %rax
je 0x4793
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x4ba8
testq %rax, %rax
je 0x4793
movq 0x30(%rbx), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2b0a
testb %al, %al
je 0x4797
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x47b5
xorl %eax, %eax
jmp 0x47bc
movq 0x30(%rbx), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2a08
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
pushq $0x1
popq %r8
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x446e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x10(%rbp), %rax
movl %esi, (%rax)
movl %edx, -0xc(%rbp)
movq %rax, %rsi
callq 0x4ba8
testq %rax, %rax
je 0x4abf
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x4ba8
testq %rax, %rax
je 0x4abf
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movb $0x1, %al
cmpl %edx, %esi
je 0x4ac1
movq 0x30(%rbx), %rdi
callq 0x2b0a
jmp 0x4ac1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq -0x1c(%rbp), %rax
movl %esi, (%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x4f4c
leaq 0x68(%rbx), %r14
leaq -0x138(%rbp), %r15
movl $0x118, %edx            # imm = 0x118
movq %r15, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r15, %rdi
callq 0x4ac8
movq %r14, %rdi
movq %r15, %rsi
callq 0x50dc
leaq -0x138(%rbp), %r14
movq %r14, %rdi
callq 0x4b66
andq $0x0, 0x20(%r14)
leaq 0xb8(%rbx), %rdi
leaq -0x108(%rbp), %r15
movq %r15, -0x30(%r15)
movq $0x1, -0x28(%r15)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r15)
movl $0x3f800000, -0x10(%r15) # imm = 0x3F800000
movups %xmm0, -0x8(%r15)
leaq -0x138(%rbp), %rsi
callq 0x7894
movq %r14, %rdi
callq 0x7710
addq $0xd0, %rbx
andq $0x0, 0x20(%r14)
movq %r15, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq -0x138(%rbp), %rsi
movq %rbx, %rdi
callq 0x7894
leaq -0x138(%rbp), %rdi
callq 0x7710
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x69d8
movq %rax, %rbx
leaq -0x138(%rbp), %rdi
callq 0x7710
jmp 0x69f8
movq %rax, %rbx
leaq -0x138(%rbp), %rdi
callq 0x4b66
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %ecx, %r12d
movq %rdi, %r14
leaq -0x30(%rbp), %rax
movl %esi, (%rax)
movl %edx, -0x2c(%rbp)
leaq 0x38(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4ba8
testq %rax, %rax
je 0x6fda
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
callq 0x4ba8
testq %rax, %rax
je 0x6fda
leaq 0x80(%r14), %r13
leaq -0x30(%rbp), %rsi
movq %r13, %rdi
callq 0x8506
leaq -0x2c(%rbp), %rcx
movl (%rcx), %ecx
movq %r12, %rbx
shlq $0x20, %rbx
orq %rbx, %rcx
leaq -0x38(%rbp), %r15
movq %rcx, (%r15)
movq %rax, %rdi
movq %r15, %rsi
callq 0x88dc
movq %r13, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x8506
leaq -0x30(%rbp), %r13
movl (%r13), %ecx
orq %rbx, %rcx
movq %rcx, (%r15)
movq %rax, %rdi
movq %r15, %rsi
callq 0x88dc
movl (%r13), %eax
leaq -0x2c(%rbp), %rbx
movl (%rbx), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7ed0
movl %r12d, (%rax)
movl (%rbx), %eax
movl (%r13), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%r15)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x7ed0
movl %r12d, (%rax)
movb $0x1, %al
jmp 0x6fdc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq 0xd0(%rsi), %rdi
leaq -0x38(%rbp), %rsi
orl $-0x1, (%rsi)
callq 0x8a4e
movq 0xd0(%r14), %r12
addq $0x10, %r12
leaq -0x38(%rbp), %r14
movq (%r12), %r12
testq %r12, %r12
je 0x7350
movq 0x28(%r12), %r15
leaq 0x18(%r12), %r13
cmpq %r13, %r15
je 0x7305
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 0x8b60
movq %r15, %rdi
callq 0x2190
movq %rax, %r15
jmp 0x7318
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7364
movq %rax, %r14
movq %rbx, %rdi
callq 0x782a
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdi, %r14
leaq -0x28(%rbp), %rax
movl %esi, (%rax)
movl %edx, -0x24(%rbp)
leaq 0x40(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4ba8
testq %rax, %rax
je 0x927c
leaq -0x24(%rbp), %rsi
movq %r15, %rdi
callq 0x4ba8
testq %rax, %rax
je 0x927c
leaq 0x70(%r14), %rdi
leaq -0x28(%rbp), %r15
movq %r15, %rsi
callq 0xa322
leaq -0x24(%rbp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xa1e6
leaq 0xa8(%r14), %rdi
movq %r12, %rsi
callq 0xa322
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1e6
addq $0x8, %r14
movl (%r15), %eax
movl (%r12), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq -0x30(%rbp), %rsi
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x7ed0
movl %ebx, (%rax)
movb $0x1, %al
jmp 0x927e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa20c
movq 0xf8(%rbx), %rax
movq 0x100(%rbx), %rcx
cmpq %rcx, %rax
je 0x92d2
movl $0x3f3f3f3f, (%rax)     # imm = 0x3F3F3F3F
addq $0x4, %rax
jmp 0x92c1
leaq 0xe0(%rbx), %rdi
movq 0x68(%rbx), %rsi
movq %rdi, -0x48(%rbp)
callq 0xa244
movq 0xe0(%rbx), %rax
movq 0xe8(%rbx), %rcx
cmpq %rcx, %rax
je 0x9303
orq $-0x1, (%rax)
addq $0x8, %rax
jmp 0x92f4
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl (%rbx), %eax
shlq $0x20, %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
callq 0x7698
movslq (%rbx), %rax
movq 0xf8(%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
movslq (%rbx), %rax
movq 0xe0(%rbx), %rcx
orq $-0x1, (%rcx,%rax,8)
leaq 0x70(%rbx), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rbx
leaq -0x38(%rbp), %r12
movq -0x70(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x93f7
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x76b8
movq -0x40(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xa322
movq (%rax), %r13
movq 0x8(%rax), %r15
cmpq %r15, %r13
je 0x9351
movl -0x2c(%rbp), %eax
movl (%r13), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7ed0
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 0x93f1
movl %esi, (%rcx,%rdx,4)
movl -0x2c(%rbp), %edx
movslq (%r13), %rsi
movq -0x48(%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 -0x70(%rbp), %rdi
movq %r12, %rsi
callq 0x7698
addq $0x4, %r13
jmp 0x9382
leaq -0x70(%rbp), %rdi
callq 0x7880
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9417
jmp 0x9417
jmp 0x9417
jmp 0x9417
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x7880
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %ecx, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %rax
movl %esi, (%rax)
movl %edx, -0x2c(%rbp)
leaq 0x40(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4ba8
testq %rax, %rax
je 0x9507
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
callq 0x4ba8
testq %rax, %rax
je 0x9507
leaq 0x8(%r14), %r15
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq -0x38(%rbp), %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
callq 0xaa90
testq %rax, %rax
je 0x9507
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq -0x38(%rbp), %r12
movq %rcx, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7ed0
movl (%rax), %r13d
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%r12)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x7ed0
movl %ebx, (%rax)
movl %ebx, %r8d
subl %r13d, %r8d
jle 0x951c
movslq -0x2c(%rbp), %rdx
movq 0xe0(%r14), %rax
movl (%rax,%rdx,8), %esi
cmpl -0x30(%rbp), %esi
jne 0x951c
movq %r14, %rdi
callq 0x9548
movb $0x1, %r15b
jmp 0x950a
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
cmpl %r13d, %ebx
jge 0x950a
movslq -0x30(%rbp), %rax
movq 0xf8(%r14), %rcx
addl (%rcx,%rax,4), %ebx
movslq -0x2c(%rbp), %rdx
subl (%rcx,%rdx,4), %ebx
jge 0x950a
movq %r14, %rdi
movl %ebx, %r8d
callq 0x9c74
jmp 0x950a
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2140
leaq -0x2c(%rbp), %rcx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl $0x1, (%rcx)
movb $0x0, (%rax)
pushq $0x1
popq %rax
leaq 0x5ce(%rip), %r15       # 0xc0b8
movq 0x74ef(%rip), %r12      # 0x12fe0
leaq -0x50(%rbp), %r13
leaq -0x70(%rbp), %rbx
testl %eax, %eax
je 0xbb52
movq 0x74cc(%rip), %rdi      # 0x12fd0
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movl -0x2c(%rbp), %r14d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21c0
movl %r14d, %edi
movq %rbx, %rsi
callq 0xb1b0
movq %rbx, %rdi
callq 0x20a0
movl -0x2c(%rbp), %eax
jmp 0xbaf9
leaq -0x50(%rbp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20a0
jmp 0xbb7d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: create_CL_vector[abi:cxx11](int, char const**)
inline vector<string> create_CL_vector(int argc, char const *argv[]){
	vector<string> vs;
	for (int i = 0; i < argc; ++i){
		vs.push_back(argv[i]);
	}
	return vs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r15d
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %r13
cmpq %rbp, %r15
je 0x7896
movq (%r14,%rbp,8), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x7776
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8d1c
movq %r12, %rdi
callq 0x3100
incq %rbp
jmp 0x786a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x78ba
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x8cf0
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: currentDate[abi:cxx11]()
inline string currentDate() {
	time_t now = time(0);
    struct tm tstruct;
    char buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%Y-%m-%d", &tstruct);
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3190
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x430c(%rip), %rdx      # 0xc57f
leaq 0x50(%rsp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x31b0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7776
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: replaceChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, char)
inline string replaceChar(string str, char ch1, char ch2) {
  for (size_t i = 0; i < str.size(); ++i) {
    if (str[i] == ch1)
      str[i] = ch2;
  }
  return str;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
cmpq 0x8(%rsi), %rax
jae 0x8312
movq (%rsi), %rdi
cmpb %dl, (%rdi,%rax)
jne 0x830d
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x82fc
movq %rbx, %rdi
callq 0x32d0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa8, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3190
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x3e1f(%rip), %rdx      # 0xc588
leaq 0x50(%rsp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x31b0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7776
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: pathToDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void pathToDir(string& directory_string, string& path_to_dir) {
	string dir1 = "./" + directory_string;              //in the directory
	string dir2 = "../" + directory_string;             //one level deep
	string dir3 = "../../" + directory_string;          //two levels deep
	string dir4 = "../../../" + directory_string;       //three levels deep
	string dir5 = "../../../../" + directory_string;    //four levels deep
	string dir6 = "../../../../../" + directory_string; //five levels deep
	// test for the correct path to the public directory from the pwd
	if (isDirPresent(dir1)) {
		path_to_dir = dir1;
	}
	else if (isDirPresent(dir2)) {
		path_to_dir = dir2;
	}
	else if (isDirPresent(dir3)) {
		path_to_dir = dir3;
	}
	else if (isDirPresent(dir4)) {
		path_to_dir = dir4;
	}
	else if (isDirPresent(dir5)) {
		path_to_dir = dir5;
	}
	else if (isDirPresent(dir6)) {
		path_to_dir = dir6;
	}
	else {
		path_to_dir = ".";
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
leaq 0x3dfe(%rip), %rsi      # 0xc642
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rdx
callq 0x81b2
leaq 0x3de3(%rip), %rsi      # 0xc641
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rdx
callq 0x81b2
leaq 0x3dc6(%rip), %rsi      # 0xc63e
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rdx
callq 0x81b2
leaq 0x3dac(%rip), %rsi      # 0xc63b
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rdx
callq 0x81b2
leaq 0x3d92(%rip), %rsi      # 0xc638
leaq 0x28(%rsp), %rdi
movq %rbp, %rdx
callq 0x81b2
leaq 0x3d7b(%rip), %rsi      # 0xc635
leaq 0x8(%rsp), %rdi
movq %rbp, %rdx
callq 0x81b2
movq %r14, %rdi
callq 0x8cb8
testl %eax, %eax
jne 0x8922
movq %r15, %rdi
callq 0x8cb8
movq %r15, %r14
testl %eax, %eax
jne 0x8922
movq %r12, %rdi
callq 0x8cb8
movq %r12, %r14
testl %eax, %eax
jne 0x8922
movq %r13, %rdi
callq 0x8cb8
movq %r13, %r14
testl %eax, %eax
jne 0x8922
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x8cb8
testl %eax, %eax
jne 0x8922
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8cb8
testl %eax, %eax
je 0x8981
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3150
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
callq 0x3100
leaq 0x48(%rsp), %rdi
callq 0x3100
leaq 0x68(%rsp), %rdi
callq 0x3100
leaq 0x88(%rsp), %rdi
callq 0x3100
leaq 0xa8(%rsp), %rdi
callq 0x3100
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cdc(%rip), %rsi      # 0xb664
movq %rbx, %rdi
callq 0x33e0
jmp 0x892d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3100
jmp 0x89a4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x89b3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3100
jmp 0x89c2
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3100
jmp 0x89d1
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x3100
leaq 0xa8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33b0
movq %rax, %rbx
jmp 0x89de
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: currentDateTime[abi:cxx11]()
inline string currentDateTime() {
    time_t now = time(0);
    struct tm tstruct;
    char buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%Y-%m-%d.%X", &tstruct);
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3190
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x3b0c(%rip), %rdx      # 0xc573
leaq 0x50(%rsp), %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x31b0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7776
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: pathToPublic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void pathToPublic(string& path_to_public) {
	string dir1 = "./public";
	string dir2 = "../public";
	string dir3 = "../../public";
	string dir4 = "../../../public";
	string dir5 = "../../../../public";
	string dir6 = "../../../../../public";
	// test for the correct path to the public directory from the pwd
	if (isDirPresent(dir1)) {
		path_to_public = "./public";
	}
	else if (isDirPresent(dir2)) {
		path_to_public = "../public";
	}
	else if (isDirPresent(dir3)) {
		path_to_public = "../../public";
	}
	else if (isDirPresent(dir4)) {
		path_to_public = "../../../public";
	}
	else if (isDirPresent(dir5)) {
		path_to_public = "../../../../public";
	}
	else if (isDirPresent(dir6)) {
		path_to_public = "../../../../../public";
	}
	else {
		path_to_public = ".";
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x3b7c(%rip), %r14      # 0xc62c
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
movq %r14, %rsi
callq 0x7776
leaq 0x3b5c(%rip), %r15      # 0xc62b
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rdx
movq %r15, %rsi
callq 0x7776
leaq 0x3b3d(%rip), %r13      # 0xc628
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r13, %rsi
callq 0x7776
leaq 0x3b21(%rip), %rbp      # 0xc625
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbp, %rsi
callq 0x7776
leaq 0x3b05(%rip), %rsi      # 0xc622
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x7776
leaq 0x3aec(%rip), %r12      # 0xc61f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x7776
leaq 0xa8(%rsp), %rdi
callq 0x8cb8
testl %eax, %eax
jne 0x8bbb
leaq 0x88(%rsp), %rdi
callq 0x8cb8
movq %r15, %r14
testl %eax, %eax
jne 0x8bbb
leaq 0x68(%rsp), %rdi
callq 0x8cb8
movq %r13, %r14
testl %eax, %eax
jne 0x8bbb
leaq 0x48(%rsp), %rdi
callq 0x8cb8
movq %rbp, %r14
testl %eax, %eax
jne 0x8bbb
leaq 0x28(%rsp), %rdi
callq 0x8cb8
leaq 0x3a85(%rip), %r14      # 0xc622
testl %eax, %eax
jne 0x8bbb
leaq 0x8(%rsp), %rdi
callq 0x8cb8
testl %eax, %eax
leaq 0x2ab0(%rip), %rax      # 0xb664
cmoveq %rax, %r12
movq %r12, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33e0
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
callq 0x3100
leaq 0x48(%rsp), %rdi
callq 0x3100
leaq 0x68(%rsp), %rdi
callq 0x3100
leaq 0x88(%rsp), %rdi
callq 0x3100
leaq 0xa8(%rsp), %rdi
callq 0x3100
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3100
jmp 0x8c2c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x8c3b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3100
jmp 0x8c4a
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3100
jmp 0x8c59
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x3100
leaq 0xa8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x33b0
movq %rax, %rbx
jmp 0x8c66
// File: /workspace/github_cpp_makefile_star2_O2/chrissimpkins[P]octopus/src/main.cpp
// Function: isDirPresent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline int isDirPresent(string& dir) {
	const char * pathname = dir.c_str();
	struct stat sb;
	if (stat(pathname, &sb) == 0 && S_ISDIR(sb.st_mode))
	{
		//directory present, return 1
	    return 1;
	}
	else {
		//directory not present, return 0
		return 0;
	}
}

// Assembly:
subq $0x98, %rsp
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3220
testl %eax, %eax
jne 0x8ce5
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x8ce5
pushq $0x1
popq %rax
jmp 0x8ce7
xorl %eax, %eax
addq $0x98, %rsp
retq
nop