LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: node_walk
void node_walk( rbnode* node, int order, rbtree_proc_node cb )
{
    if( !node )
        return;

    switch( order )
    {
        case RBTREE_WALK_PRE_ORDER:
            cb( node );
            node_walk( node->left, order, cb );
            node_walk( node->right, order, cb );
            break;
        
        case RBTREE_WALK_IN_ORDER:
            node_walk( node->left, order, cb );
            cb( node );
            node_walk( node->right, order, cb );
            break;
        
        case RBTREE_WALK_POST_ORDER:
            node_walk( node->left, order, cb );
            node_walk( node->right, order, cb );
            cb( node );
            break;
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbbcf
jmp 0xbc8d
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0xbbf3
jmp 0xbbdc
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xbc27
jmp 0xbbe6
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xbc5b
jmp 0xbc8d
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
jmp 0xbc8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
jmp 0xbc8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_free
void rbtree_free( rbtree* tree, rbtree_proc_node cb )
{
    if( !tree->root )
        return;

    node_free( tree->root, cb );
    tree->root = NULL;
    tree->count = 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbcbc
jmp 0xbce2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbcf0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: node_free
void node_free( rbnode* node, rbtree_proc_node cb )
{
    if( node->left )
        node_free( node->left, cb );
    
    if( node->right )
        node_free( node->right, cb );
    
    cb( node );
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xbd1c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbcf0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbd38
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbcf0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_dot
void rbtree_dot( rbtree* tree, char* file, rbtree_node_value cb )
{
    FILE* f;
    rbnode* node;
    
    f = fopen( file, "w" );
    if( !f )
        return;
    
    fprintf( f, "digraph rbtree{\n" );
    
    if( tree->root )
    {
        node= tree->root;
        fprintf( f, "n_%p[color=%s,fontcolor=white, style=filled, shape=circle, label=\"%s\"];\n", node, node->color == RED ? "red" : "black", cb( node ) );
        node_dot( tree->root, f, cb );
    }
    else
        fprintf( f, "nil[color=black, fontcolor=white, style=filled, shape=box, label=\"nil\"];\n" );
    
    fprintf( f, "}\n" );
    fclose( f );
    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3a69(%rip), %rsi      # 0xf9d8
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbf84
jmp 0xc044
movq -0x20(%rbp), %rdi
leaq 0x3a4b(%rip), %rsi      # 0xf9da
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc017
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edx
leaq 0x3987(%rip), %rax      # 0xf94f
leaq 0x397c(%rip), %rcx      # 0xf94b
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rax, %r8
leaq 0x39f1(%rip), %rsi      # 0xf9eb
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbd50
jmp 0xc029
movq -0x20(%rbp), %rdi
leaq 0x3a12(%rip), %rsi      # 0xfa34
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rdi
leaq 0x3a4a(%rip), %rsi      # 0xfa7e
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rdi
callq 0x20e0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: insert_case3
void insert_case3( rbtree* tree, rbnode* node )
{
    if(uncle(node) != NULL && uncle (node)->color == RED) {
         node->parent->color = BLACK;
         uncle (node)->color = BLACK;
         grandparent (node)->color = RED;
         insert_case1( tree, grandparent(node));
    }
    else
         insert_case4 (tree, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc120
cmpq $0x0, %rax
je 0xc108
movq -0x10(%rbp), %rdi
callq 0xc120
cmpl $0x1, (%rax)
jne 0xc108
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
callq 0xc120
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
callq 0xc180
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xb5d0
jmp 0xc115
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc1a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: uncle
static rbnode* uncle( rbnode *n ){
     if(n->parent == grandparent(n)->left)
         return grandparent (n)->right;
     else
         return grandparent (n)->left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0xc161
movq -0x10(%rbp), %rdi
callq 0xc180
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc172
movq -0x10(%rbp), %rdi
callq 0xc180
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: insert_case4
void insert_case4( rbtree* tree, rbnode* n )
{

    if(n == n->parent->right && n->parent == grandparent(n)->left) {
    /*
                 G
                /
               P
                \
                 N
    */
        rotate_left( tree, n->parent);
        n = n->left;
    } else if(n == n->parent->left && n->parent == grandparent(n)->right) {
    /*
                 G
                  \
                   P
                  /
                 N
    */
        rotate_right( tree, n->parent);
        n = n->right;
    }
    insert_case5 (tree, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0xc203
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0xc203
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc270
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc256
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc254
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jne 0xc254
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc350
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc256
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rotate_left
void rotate_left( rbtree* tree, rbnode* node )
{
    //printf( "roate left of node %d\n", node->value );
    
    rbnode* parent = node->parent;
    rbnode* child = node->right;
    
    int parent_flag = 0;
    
    if( parent )
    {
        if( node == parent->left )
            parent_flag = 'L';
        else
            parent_flag = 'R';
    }
    
    if( parent_flag )
    {
        if( parent_flag == 'L' )
            parent->left = child;
        else
            parent->right = child;
    }
    
    node->right = child->left;
    if( child->left )
        child->left->parent = node;
    node->parent = child;
    
    child->left = node;
    child->parent = parent;
    
    if( !parent )
        tree->root = child;
    
    
    return;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc2c2
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc2b9
movl $0x4c, -0x24(%rbp)
jmp 0xc2c0
movl $0x52, -0x24(%rbp)
jmp 0xc2c2
cmpl $0x0, -0x24(%rbp)
je 0xc2ea
cmpl $0x4c, -0x24(%rbp)
jne 0xc2dc
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc2e8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc2ea
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc315
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0xc34b
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rotate_right
void rotate_right( rbtree* tree, rbnode* node )
{
    //printf( "roate right of node %d\n", node->value );
    
    rbnode* parent = node->parent;
    rbnode* child = node->left;
    
    int parent_flag = 0;
    
    if( parent )
    {
        if( node == parent->left )
            parent_flag = 'L';
        else
            parent_flag = 'R';
    }
    
    if( parent_flag )
    {
        if( parent_flag == 'L' )
            parent->left = child;
        else
            parent->right = child;
    }
    
    node->left = child->right;
    if( child->right )
        child->right->parent = node;
    node->parent = child;
    
    child->right = node;
    child->parent = parent;
    
    if( !parent )
        tree->root = child;
    
    
    return;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc3a2
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc399
movl $0x4c, -0x24(%rbp)
jmp 0xc3a0
movl $0x52, -0x24(%rbp)
jmp 0xc3a2
cmpl $0x0, -0x24(%rbp)
je 0xc3ca
cmpl $0x4c, -0x24(%rbp)
jne 0xc3bc
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc3c8
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc3ca
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc3f5
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0xc42b
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: insert_case5
void insert_case5( rbtree* tree, rbnode* n )
{
    n->parent->color = BLACK;
    grandparent (n)->color = RED;
    if(n == n->parent->left && n->parent == grandparent(n)->left) {
        rotate_right( tree, grandparent(n));
    } else {
        /* Here, n == n->parent->right && n->parent == grandparent (n)->right */
        rotate_left( tree, grandparent(n));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
callq 0xc180
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc4b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0xc4b0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xc350
jmp 0xc4cd
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xc270
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_path_black_count
int rbtree_path_black_count( rbnode* n )
{
    int cnt = 0;
    while( n )
    {
        if( n->color == BLACK )
            cnt++;
        n = n->left;
    }
    
    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc516
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc508
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc4ef
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: node_black_walk
int node_black_walk( rbnode* n, int find, int count )
{
    int rc;
    
    if( !n )
    {
        if( find != count )
        {
            printf( "black node in path not equal!\n" );
            return 1;
        }
        return 0;
    }
    else
    {
        if( n->color == BLACK )
            find ++;
        rc = node_black_walk( n->left, find, count );
        if( rc )
            return rc;
        rc = node_black_walk( n->right, find, count );
        if( rc )
            return rc;
        
        return 0;
    }
    
    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc561
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0xc558
leaq 0x3539(%rip), %rdi      # 0xfa81
movb $0x0, %al
callq 0x2120
movl $0x1, -0x4(%rbp)
jmp 0xc5c2
movl $0x0, -0x4(%rbp)
jmp 0xc5c2
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc573
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xc520
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xc597
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc5c2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xc520
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xc5bb
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc5c2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: delete_case2
void delete_case2( rbtree* tree, rbnode *n)
{
        rbnode *s = sibling (n);
 
        if(s->color == RED){
                n->parent->color = RED;
                s->color = BLACK;
                if(n == n->parent->left)
                        rotate_left(tree, n->parent);
                else
                        rotate_right(tree, n->parent);
        } 
        delete_case3 (tree, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc660
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xc646
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc633
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc270
jmp 0xc644
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc350
jmp 0xc646
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc6b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: delete_case3
void delete_case3( rbtree* tree, rbnode *n)
{
        rbnode *s = sibling (n);
 
        if( (n->parent->color == BLACK)&&
            ( node_color( s ) == BLACK)&&
            ( node_color( s->left ) == BLACK)&&
            ( node_color( s->right ) == BLACK)) {
                s->color = RED;
                delete_case1(tree, n->parent);
        } else
                delete_case4 (tree, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc660
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, (%rax)
jne 0xc729
movq -0x18(%rbp), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc729
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc729
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc729
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xb9c0
jmp 0xc736
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc740
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: delete_case4
void delete_case4( rbtree* tree, rbnode *n)
{
        rbnode *s = sibling (n);
 
        if( (n->parent->color == RED)&&
            ( node_color( s ) == BLACK)&&
            ( node_color( s->left ) == BLACK)&&
            ( node_color( s->right ) == BLACK))
        {
                s->color = RED;
                n->parent->color = BLACK;
        } else
                delete_case5 (tree, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc660
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x1, (%rax)
jne 0xc7b6
movq -0x18(%rbp), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc7b6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc7b6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc7b6
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x2, (%rax)
jmp 0xc7c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc7d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: delete_case5
void delete_case5( rbtree* tree, rbnode *n )
{
        rbnode *s = sibling (n);
 
        if(s->color == BLACK){ /* this if statement is trivial, 
due to Case 2(even though Case two changed the sibling to a sibling's child, 
the sibling's child can't be red, since no red parent can have a red child). */
// the following statements just force the red to be on the left of the left of the parent, 
// or right of the right, so case six will rotate correctly.
                if( (n == n->parent->left)&&
                    ( node_color( s->right ) == BLACK)&&
                    ( node_color( s->left ) == RED))
                { // this last test is trivial too due to cases 2-4.
                        s->color = RED;
                        s->left->color = BLACK;
                        rotate_right (tree, s);
                } else if(
                    (n == n->parent->right)&&
                    ( node_color( s->left ) == BLACK)&&
                    ( node_color( s->right ) == RED)) 
                {// this last test is trivial too due to cases 2-4.
                        s->color = RED;
                        s->right->color = BLACK;
                        rotate_left (tree, s);
                }
        }
        delete_case6 (tree, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc660
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc8b6
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc857
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc857
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb990
cmpl $0x1, %eax
jne 0xc857
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc350
jmp 0xc8b4
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jne 0xc8b2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb990
cmpl $0x2, %eax
jne 0xc8b2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb990
cmpl $0x1, %eax
jne 0xc8b2
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc270
jmp 0xc8b4
jmp 0xc8b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc8d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: delete_case6
void delete_case6( rbtree* tree, rbnode *n )
{
        rbnode *s = sibling (n);
 
        s->color = n->parent->color;
        n->parent->color = BLACK;
 
        if(n == n->parent->left){
                s->right->color = BLACK;
                rotate_left(tree, n->parent);
        } else {
                s->left->color = BLACK;
                rotate_right(tree, n->parent);
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc660
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc93e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc270
jmp 0xc95d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc350
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: test_ints
void test_ints() // {{{
{
  const char *bufs[]={
    "\x8b",  // 0
    "\xef",  // 100
    "\x27",  // -100
    "\xfa\x7c",  // 1000
    "\xfe\x7c",  // -1000
    "\x1c\x27\x10",  // 10000
    "\x1c\xd8\xf0",  // -10000
    "\x1d\x00\x01\x86\xa0",  // 100000
    "\x1d\xff\xfe\x79\x60",  // -100000
    NULL
  };
  char out[10];
  int iA;
  for (iA=0;bufs[iA];iA++) {
    const char *tmp=bufs[iA];
    int32_t val=cff_read_integer(&tmp);
    printf("%d\n",val);
    char *o=out;
    cff_write_integer(&o,val);
    dump(out,o);
//    assert(memcmp(out,bufs[iA],o-out)==0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x50(%rbp), %rdi
leaq 0xa25a(%rip), %rsi      # 0xe5c0
movl $0x50, %edx
callq 0x4100
movl $0x0, -0x60(%rbp)
movslq -0x60(%rbp), %rax
cmpq $0x0, -0x50(%rbp,%rax,8)
je 0x43d9
movslq -0x60(%rbp), %rax
movq -0x50(%rbp,%rax,8), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7ba0
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %esi
leaq 0x6027(%rip), %rdi      # 0xa3cd
movb $0x0, %al
callq 0x4040
leaq -0x5a(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x6c(%rbp), %esi
leaq -0x78(%rbp), %rdi
callq 0x7e60
leaq -0x5a(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x42f0
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x4377
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: test_real
void test_real(double v) // {{{
{
  char buf[10],*b=buf;
  cff_write_real(&b,v);
  dump(buf,b);

  const char *c=buf;
  double res=cff_read_real(&c);
  printf("%g\n",res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x12(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
callq 0x79a0
leaq -0x12(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x42f0
leaq -0x12(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7720
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
leaq 0x5c22(%rip), %rdi      # 0xa064
movb $0x1, %al
callq 0x4040
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: dump_name_index
void dump_name_index(CFF_FILE *cff) // {{{
{
  printf("Name index: %d entries\n",
         cff->nameIndex.count);
  if (cff->nameIndex.count==0) {
    return;
  }
  int iA;
  for (iA=0;iA<cff->nameIndex.count;iA++) {
    printf("  %d: %.*s\n",
           iA,
           cff_index_length(&cff->nameIndex,iA),
           cff_index_get(&cff->nameIndex,iA));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x20(%rax), %esi
leaq 0x5bfd(%rip), %rdi      # 0xa068
movb $0x0, %al
callq 0x4040
movq -0x8(%rbp), %rax
movzwl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x4481
jmp 0x44e2
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0x44e2
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
callq 0x44f0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
callq 0x4550
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movq %rax, %rcx
leaq 0x5bb0(%rip), %rdi      # 0xa080
movb $0x0, %al
callq 0x4040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4488
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: dump_string_index
void dump_string_index(CFF_FILE *cff) // {{{
{
  printf("String index: %d extra entries\n",
         cff->stringIndex.count);
  if (cff->stringIndex.count==0) {
    return;
  }
  int iA;
  for (iA=0;iA<cff->stringIndex.count;iA++) {
    printf("  %d: %.*s\n",
           iA+391,
           cff_index_length(&cff->stringIndex,iA),
           cff_index_get(&cff->stringIndex,iA));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x50(%rax), %esi
leaq 0x5ac1(%rip), %rdi      # 0xa08c
movb $0x0, %al
callq 0x4040
movq -0x8(%rbp), %rax
movzwl 0x50(%rax), %eax
cmpl $0x0, %eax
jne 0x45e1
jmp 0x4647
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x50(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4647
movl -0xc(%rbp), %eax
addl $0x187, %eax            # imm = 0x187
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %esi
callq 0x44f0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %esi
callq 0x4550
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movq %rax, %rcx
leaq 0x5a4b(%rip), %rdi      # 0xa080
movb $0x0, %al
callq 0x4040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x45e8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: dump_value
void dump_value(CFF_FILE *cff,struct _CFF_VALUE *value,int args) // {{{
{
  if (!value) {
    printf("null");
    return;
  }
  switch (value->type) {
  case CFF_VAL_ERROR:
    printf("ERROR");
    break;
  case CFF_VAL_OP:
    printf(" %s",value->op->name);
    if (args>=0) {
      dump_op(cff,value,args);
    }
    printf("\n");
    break;
  case CFF_VAL_INT:
    printf(" %d",value->number);
    break;
  case CFF_VAL_REAL:
    printf(" %gf",value->real);
    break;
  default:
    assert(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x487d
leaq 0x58fd(%rip), %rdi      # 0xa16e
movb $0x0, %al
callq 0x4040
jmp 0x4946
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x4927
movq -0x20(%rbp), %rax
leaq 0x5794(%rip), %rcx      # 0xa030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x58c7(%rip), %rdi      # 0xa173
movb $0x0, %al
callq 0x4040
jmp 0x4946
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0x58af(%rip), %rdi      # 0xa179
movb $0x0, %al
callq 0x4040
cmpl $0x0, -0x14(%rbp)
jl 0x48e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4650
leaq 0x5b69(%rip), %rdi      # 0xa457
movb $0x0, %al
callq 0x4040
jmp 0x4946
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x5878(%rip), %rdi      # 0xa17d
movb $0x0, %al
callq 0x4040
jmp 0x4946
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x5863(%rip), %rdi      # 0xa181
movb $0x1, %al
callq 0x4040
jmp 0x4946
leaq 0x7190(%rip), %rdi      # 0xbabe
leaq 0x5783(%rip), %rsi      # 0xa0b8
movl $0xa7, %edx
leaq 0x5845(%rip), %rcx      # 0xa186
callq 0x40d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: dump_dict
void dump_dict(CFF_FILE *cff,struct _CFF_DICT *dict) // {{{
{
  int iA,lastoppos=-1;
  printf("<\n");
  for (iA=0;iA<dict->len;iA++) {
    dump_value(cff,&dict->data[iA],iA-lastoppos-1);
    if (dict->data[iA].type==CFF_VAL_OP) {
      lastoppos=iA;
    }
  }
  printf(">\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
leaq 0x584e(%rip), %rdi      # 0xa1bc
movb $0x0, %al
callq 0x4040
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x49d7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
subl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x4850
movq -0x10(%rbp), %rax
addq $0x8, %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x49ca
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x49cc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x497c
leaq 0x57e1(%rip), %rdi      # 0xa1bf
movb $0x0, %al
callq 0x4040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/test_cff.c
// Function: is_sfnt_cff
int is_sfnt_cff(FILE *f) // {{{
{
  char buf[8];
  const int res=fread(buf,1,8,f);
  rewind(f); // esp. for cff_load

  if (res<8) {
    return 0;
  }
  if (memcmp(buf,"OTTO",4)==0) {
    return 1;
  } else if (memcmp(buf,"wOFFOTTO",8)==0) {
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x8, %edx
callq 0x41a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4050
cmpl $0x8, -0x1c(%rbp)
jge 0x4a2e
movl $0x0, -0x4(%rbp)
jmp 0x4a7e
leaq -0x18(%rbp), %rax
movl (%rax), %eax
subl $0x4f54544f, %eax       # imm = 0x4F54544F
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4a4d
movl $0x1, -0x4(%rbp)
jmp 0x4a7e
leaq -0x18(%rbp), %rax
movq (%rax), %rax
movabsq $0x4f54544f46464f77, %rcx # imm = 0x4F54544F46464F77
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4a75
movl $0x1, -0x4(%rbp)
jmp 0x4a7e
jmp 0x4a77
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_read_integer
int32_t cff_read_integer(const char **buf) // {{{
{
  const char *b=*buf;
  const unsigned char b0=*b;
  if (b0==28) { // size 3
    (*buf)+=3;
    return (b[1]<<8)|
           (unsigned char)b[2];
  } else if (b0==29) { // size 5
    (*buf)+=5;
    return (b[1]<<24)|
           ((unsigned char)b[2]<<16)|
           ((unsigned char)b[3]<<8)|
           (unsigned char)b[4];
  } else if (b0<32) {
    // 30 real number, 31 reserved, <28 opval/reserved
  } else if (b0<247) { // size 1
    (*buf)++;
    return (int)b0-139;
  } else if (b0<251) { // size 2
    (*buf)+=2;
    return (b0-247)*256+(unsigned char)b[1]+108;
  } else if (b0<255) { // size 2
    (*buf)+=2;
    return -(b0-251)*256-(unsigned char)b[1]-108;
  } // else: 255 reserved
  assert(0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x1c, %eax
jne 0x7bf4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7d16
movzbl -0x19(%rbp), %eax
cmpl $0x1d, %eax
jne 0x7c42
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
shll $0x18, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7d16
movzbl -0x19(%rbp), %eax
cmpl $0x20, %eax
jge 0x7c50
jmp 0x7cf3
movzbl -0x19(%rbp), %eax
cmpl $0xf7, %eax
jge 0x7c7a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movzbl -0x19(%rbp), %eax
subl $0x8b, %eax
movl %eax, -0x4(%rbp)
jmp 0x7d16
movzbl -0x19(%rbp), %eax
cmpl $0xfb, %eax
jge 0x7cb1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movzbl -0x19(%rbp), %eax
subl $0xf7, %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
addl $0x6c, %eax
movl %eax, -0x4(%rbp)
jmp 0x7d16
movzbl -0x19(%rbp), %eax
cmpl $0xff, %eax
jge 0x7ced
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movzbl -0x19(%rbp), %ecx
subl $0xfb, %ecx
xorl %eax, %eax
subl %ecx, %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
subl %ecx, %eax
subl $0x6c, %eax
movl %eax, -0x4(%rbp)
jmp 0x7d16
jmp 0x7cef
jmp 0x7cf1
jmp 0x7cf3
jmp 0x7cf5
jmp 0x7cf7
leaq 0x3dc0(%rip), %rdi      # 0xbabe
leaq 0x23b8(%rip), %rsi      # 0xa0bd
movl $0x98, %edx
leaq 0x2b67(%rip), %rcx      # 0xa878
callq 0x40d0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_read_dict_token
struct _CFF_VALUE cff_read_dict_token(const char **buf) // {{{
{
  struct _CFF_VALUE ret;
  const char *b=*buf;
  const unsigned char b0=*b;
  if (b0<22) { // operator, size 1 or size 2
    int opvalue=b0;
    (*buf)++;
    if (opvalue==12) {
      opvalue=(opvalue<<8)|((unsigned char)b[1]);
      (*buf)++;
    }
    ret.op=cffop_get_by_value(opvalue);
    if (!ret.op) {
      ret.type=CFF_VAL_ERROR;
    } else {
      ret.type=CFF_VAL_OP;
    }
  } else if (b0==30) { // real, varsize
    (*buf)++;
    ret.real=cff_read_real(buf);
    if (isnan(ret.real)) {
      ret.type=CFF_VAL_ERROR;
    } else {
      ret.type=CFF_VAL_REAL;
    }
  } else if ( (b0>=28)&&(b0!=31)&&(b0<=254) ) {
    ret.type=CFF_VAL_INT;
    ret.number=cff_read_integer(buf);
  } else { // 22-27,31,255 reserved
    assert(0);
    ret.type=CFF_VAL_ERROR;
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x16, %eax
jge 0x7dad
movzbl -0x21(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
cmpl $0xc, -0x28(%rbp)
jne 0x7d85
movl -0x28(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x28(%rbp), %edi
callq 0x90d0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7da1
movl $0x0, -0x10(%rbp)
jmp 0x7da8
movl $0x1, -0x10(%rbp)
jmp 0x7e4b
movzbl -0x21(%rbp), %eax
cmpl $0x1e, %eax
jne 0x7df6
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x7720
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7de4
jmp 0x7ded
movl $0x0, -0x10(%rbp)
jmp 0x7df4
movl $0x3, -0x10(%rbp)
jmp 0x7e49
movzbl -0x21(%rbp), %eax
cmpl $0x1c, %eax
jl 0x7e28
movzbl -0x21(%rbp), %eax
cmpl $0x1f, %eax
je 0x7e28
movzbl -0x21(%rbp), %eax
cmpl $0xfe, %eax
jg 0x7e28
movl $0x2, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7ba0
movl %eax, -0x8(%rbp)
jmp 0x7e47
leaq 0x3c8f(%rip), %rdi      # 0xbabe
leaq 0x2287(%rip), %rsi      # 0xa0bd
movl $0xbe, %edx
leaq 0x2a5e(%rip), %rcx      # 0xa8a0
callq 0x40d0
jmp 0x7e49
jmp 0x7e4b
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_write_integer
void cff_write_integer(char **buf,int32_t value) // {{{
{
  char *b=*buf;
  if ( (value>=-107)&&(value<=107) ) { // size 1
    b[0]=value+139;
    (*buf)++;
  } else if ( (value>=108)&&(value<=1131) ) { // size 2
    value-=108;
    b[0]=(value>>8)+247;
    b[1]=value&0xff;
    (*buf)+=2;
  } else if ( (value>=-1131)&&(value<=-108) ) { // size 2
    value=-value-108;
    b[0]=(value>>8)+251;
    b[1]=value&0xff;
    (*buf)+=2;
  } else if ( (value>=-32768)&&(value<=32767) ) { // size 3
    b[0]=28;
    b[1]=(value>>8)&0xff;
    b[2]=value&0xff;
    (*buf)+=3;
  } else { // size 5
    b[0]=29;
    b[1]=(value>>24)&0xff;
    b[2]=(value>>16)&0xff;
    b[3]=(value>>8)&0xff;
    b[4]=value&0xff;
    (*buf)+=5;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x6b, -0xc(%rbp)
jl 0x7ea5
cmpl $0x6b, -0xc(%rbp)
jg 0x7ea5
movl -0xc(%rbp), %eax
addl $0x8b, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x7ffb
cmpl $0x6c, -0xc(%rbp)
jl 0x7ef4
cmpl $0x46b, -0xc(%rbp)      # imm = 0x46B
jg 0x7ef4
movl -0xc(%rbp), %eax
subl $0x6c, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
addl $0xf7, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x7ff9
cmpl $0xfffffb95, -0xc(%rbp) # imm = 0xFFFFFB95
jl 0x7f45
cmpl $-0x6c, -0xc(%rbp)
jg 0x7f45
xorl %eax, %eax
subl -0xc(%rbp), %eax
subl $0x6c, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
addl $0xfb, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x7ff7
cmpl $0xffff8000, -0xc(%rbp) # imm = 0xFFFF8000
jl 0x7f93
cmpl $0x7fff, -0xc(%rbp)     # imm = 0x7FFF
jg 0x7f93
movq -0x18(%rbp), %rax
movb $0x1c, (%rax)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
jmp 0x7ff5
movq -0x18(%rbp), %rax
movb $0x1d, (%rax)
movl -0xc(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
jmp 0x7ff7
jmp 0x7ff9
jmp 0x7ffb
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_write_dict_token
void cff_write_dict_token(char **buf,const struct _CFF_VALUE *value) // {{{
{
  assert(value);
  switch (value->type) {
  case CFF_VAL_ERROR:
  default:
    assert(0);
    return;
  case CFF_VAL_OP:
    if (value->op->value>=0x0c00) {
      *((*buf)++)=12;
      *((*buf)++)=(value->op->value)&0xff;
    } else {
      *((*buf)++)=value->op->value;
    }
    break;
  case CFF_VAL_INT:
    cff_write_integer(buf,value->number);
    break;
  case CFF_VAL_REAL:
    *((*buf)++)=30;
    cff_write_real(buf,value->real);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8019
jmp 0x8038
leaq 0x28b5(%rip), %rdi      # 0xa8d5
leaq 0x2096(%rip), %rsi      # 0xa0bd
movl $0xe7, %edx
leaq 0x28a8(%rip), %rcx      # 0xa8db
callq 0x40d0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x805e
movq -0x18(%rbp), %rax
leaq 0x27a5(%rip), %rcx      # 0xa7f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x805e
leaq 0x3a59(%rip), %rdi      # 0xbabe
leaq 0x2051(%rip), %rsi      # 0xa0bd
movl $0xeb, %edx
leaq 0x2863(%rip), %rcx      # 0xa8db
callq 0x40d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xc00, 0x8(%rax)       # imm = 0xC00
jl 0x80c9
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0xc, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x80e9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x8123
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x7e60
jmp 0x8123
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x1e, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x79a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_get_string
const char *cff_get_string(CFF_FILE *cff,int sid,int *retlen) // {{{  or NULL
{
  assert(cff);
  assert( (sid>=0)&&(sid<=65000) );
  if (sid<=390) {
    const char *ret=cff_get_stdstr(sid);
    if (retlen) {
      *retlen=strlen(ret);
    }
    return ret;
  }
  sid-=391;
  if (cff->stringIndex.count==0) {
    return NULL;
  }
  assert(cff->stringIndex.offSize!=OFFERR);
  if (retlen) {
    *retlen=cff_index_length(&cff->stringIndex,sid);
  }
  return cff_index_get(&cff->stringIndex,sid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x83ac
jmp 0x83cb
leaq 0x1e1b(%rip), %rdi      # 0xa1ce
leaq 0x1d03(%rip), %rsi      # 0xa0bd
movl $0x16c, %edx            # imm = 0x16C
leaq 0x25d7(%rip), %rcx      # 0xa99d
callq 0x40d0
cmpl $0x0, -0x14(%rbp)
jl 0x83dc
cmpl $0xfde8, -0x14(%rbp)    # imm = 0xFDE8
jg 0x83dc
jmp 0x83fb
leaq 0x25ed(%rip), %rdi      # 0xa9d0
leaq 0x1cd3(%rip), %rsi      # 0xa0bd
movl $0x16d, %edx            # imm = 0x16D
leaq 0x25a7(%rip), %rcx      # 0xa99d
callq 0x40d0
cmpl $0x186, -0x14(%rbp)     # imm = 0x186
jg 0x8435
movl -0x14(%rbp), %edi
callq 0x9210
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8428
movq -0x28(%rbp), %rdi
callq 0x4090
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x84b5
movl -0x14(%rbp), %eax
subl $0x187, %eax            # imm = 0x187
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x50(%rax), %eax
cmpl $0x0, %eax
jne 0x8457
movq $0x0, -0x8(%rbp)
jmp 0x84b5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
je 0x8463
jmp 0x8482
leaq 0x257d(%rip), %rdi      # 0xa9e7
leaq 0x1c4c(%rip), %rsi      # 0xa0bd
movl $0x179, %edx            # imm = 0x179
leaq 0x2520(%rip), %rcx      # 0xa99d
callq 0x40d0
cmpq $0x0, -0x20(%rbp)
je 0x84a1
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movl -0x14(%rbp), %esi
callq 0x84c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movl -0x14(%rbp), %esi
callq 0x8520
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/cff.c
// Function: cff_load2
CFF_FILE *cff_load2(const char *buf,size_t len,int take) // {{{
{
  assert(buf);
  CFF_FILE *ret=cff_new();
  if (ret) {
    if (take) {
      ret->flags|=CFF_F_FREE_DATA;
    }
    ret->font=buf;
    ret->length=len;

    int pos=cff_read_header(ret);
    if (pos>=0) {
      pos=cff_do_load(ret,pos);
    }
    if (pos<0) {
      cff_close(ret);
      return NULL;
    }
  } else if (take) {
    free((char *)buf);
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x859c
jmp 0x85bb
leaq 0x1c66(%rip), %rdi      # 0xa209
leaq 0x1b13(%rip), %rsi      # 0xa0bd
movl $0x211, %edx            # imm = 0x211
leaq 0x2452(%rip), %rcx      # 0xaa08
callq 0x40d0
callq 0x8bc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8631
cmpl $0x0, -0x1c(%rbp)
je 0x85de
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x8660
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x8616
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x8790
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x862f
movq -0x28(%rbp), %rdi
callq 0x88e0
movq $0x0, -0x8(%rbp)
jmp 0x864a
jmp 0x8642
cmpl $0x0, -0x1c(%rbp)
je 0x8640
movq -0x10(%rbp), %rdi
callq 0x4150
jmp 0x8642
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)