LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/basic.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;
    xmpp_log_t *log;
    char *jid, *pass, *host;

    /* take a jid and password on the command line */
    if (argc < 3 || argc > 4) {
        fprintf(stderr, "Usage: basic <jid> <pass> [<host>]\n\n");
        return 1;
    }

    jid = argv[1];
    pass = argv[2];
    host = NULL;

    if (argc == 4)
        host = argv[3];

    /* init library */
    xmpp_initialize();

    /* create a context */
    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
    ctx = xmpp_ctx_new(NULL, log);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, jid);
    xmpp_conn_set_pass(conn, pass);

    /* initiate connection */
    xmpp_connect_client(conn, host, 0, conn_handler, ctx);

    /* enter the event loop -
       our connect handler will trigger an exit */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* final shutdown of the library */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jl 0x24f2
cmpl $0x4, -0x8(%rbp)
jle 0x2516
movq 0x15aef(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10b28(%rip), %rsi     # 0x1302b
movb $0x0, %al
callq 0x20d0
movl $0x1, -0x4(%rbp)
jmp 0x25d1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpl $0x4, -0x8(%rbp)
jne 0x2548
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x59f0
xorl %edi, %edi
callq 0x5aa0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x44c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4ea0
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4f20
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %r8
xorl %edx, %edx
leaq -0x155(%rip), %rcx      # 0x2450
callq 0x4fa0
movq -0x18(%rbp), %rdi
callq 0x6a70
movq -0x20(%rbp), %rdi
callq 0x4ab0
movq -0x18(%rbp), %rdi
callq 0x6040
callq 0x5a00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: Encrypt_StateUpdate128_1bit
void Encrypt_StateUpdate128_1bit(unsigned char *state, unsigned char plaintextbit, unsigned char *ciphertextbit, unsigned char *ks, unsigned char ca, unsigned char cb)
{
    unsigned int  j;
    unsigned char f;

    state[289] ^= state[235] ^ state[230];
    state[230] ^= state[196] ^ state[193];
    state[193] ^= state[160] ^ state[154];
    state[154] ^= state[111] ^ state[107];
    state[107] ^= state[66]  ^ state[61];
    state[61]  ^= state[23]  ^ state[0];

    f  = FBK128(state, ks, ca, cb);

    for (j = 0; j <= 291; j++) state[j] = state[j+1];
    state[292] = f ^ plaintextbit;
    *ciphertextbit = *ks ^ plaintextbit;
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, %rax
movl 0x4(%rsp), %ecx
movq %rax, 0x8(%rsp)
movq %rdx, %rax
movq 0x8(%rsp), %rdx
movq %rax, 0x10(%rsp)
movl %esi, %eax
movq 0x10(%rsp), %rsi
movl %eax, 0x18(%rsp)
movq %rdi, %r8
movl 0x18(%rsp), %edi
movb %r9b, %al
movq %r8, 0x40(%rsp)
movb %dil, 0x3f(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movb %cl, 0x27(%rsp)
movb %al, 0x26(%rsp)
movq 0x40(%rsp), %rax
movzbl 0xeb(%rax), %edx
movq 0x40(%rsp), %rax
movzbl 0xe6(%rax), %eax
xorl %eax, %edx
movq 0x40(%rsp), %rax
movzbl 0x121(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x121(%rax)
movq 0x40(%rsp), %rax
movzbl 0xc4(%rax), %edx
movq 0x40(%rsp), %rax
movzbl 0xc1(%rax), %eax
xorl %eax, %edx
movq 0x40(%rsp), %rax
movzbl 0xe6(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xe6(%rax)
movq 0x40(%rsp), %rax
movzbl 0xa0(%rax), %edx
movq 0x40(%rsp), %rax
movzbl 0x9a(%rax), %eax
xorl %eax, %edx
movq 0x40(%rsp), %rax
movzbl 0xc1(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xc1(%rax)
movq 0x40(%rsp), %rax
movzbl 0x6f(%rax), %edx
movq 0x40(%rsp), %rax
movzbl 0x6b(%rax), %eax
xorl %eax, %edx
movq 0x40(%rsp), %rax
movzbl 0x9a(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x9a(%rax)
movq 0x40(%rsp), %rax
movzbl 0x42(%rax), %edx
movq 0x40(%rsp), %rax
movzbl 0x3d(%rax), %eax
xorl %eax, %edx
movq 0x40(%rsp), %rax
movzbl 0x6b(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x6b(%rax)
movq 0x40(%rsp), %rax
movzbl 0x17(%rax), %edx
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
xorl %eax, %edx
movq 0x40(%rsp), %rax
movzbl 0x3d(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x3d(%rax)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movb 0x27(%rsp), %al
movzbl %al, %edx
movzbl 0x26(%rsp), %ecx
callq 0x1070
movb %al, 0x1f(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x123, 0x20(%rsp)      # imm = 0x123
ja 0x14d3
movq 0x40(%rsp), %rax
movl 0x20(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x40(%rsp), %rax
movl 0x20(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x149f
movzbl 0x1f(%rsp), %eax
movzbl 0x3f(%rsp), %ecx
xorl %ecx, %eax
movb %al, %cl
movq 0x40(%rsp), %rax
movb %cl, 0x124(%rax)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movzbl 0x3f(%rsp), %ecx
xorl %ecx, %eax
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: Decrypt_StateUpdate128_1bit
void Decrypt_StateUpdate128_1bit(unsigned char *state, unsigned char *plaintextbit, unsigned char ciphertextbit, unsigned char *ks, unsigned char ca, unsigned char cb)
{
    unsigned int  j;
    unsigned char f;

    state[289] ^= state[235] ^ state[230];
    state[230] ^= state[196] ^ state[193];
    state[193] ^= state[160] ^ state[154];
    state[154] ^= state[111] ^ state[107];
    state[107] ^= state[66]  ^ state[61];
    state[61]  ^= state[23]  ^ state[0];

    f = FBK128(state, ks, ca, cb);

    for (j = 0; j <= 291; j++) state[j] = state[j+1];
    *plaintextbit = *ks ^ ciphertextbit;
    state[292] = f ^ *plaintextbit;
}

// Assembly:
subq $0x58, %rsp
movl %r8d, 0xc(%rsp)
movq %rcx, %rax
movl 0xc(%rsp), %ecx
movq %rax, 0x10(%rsp)
movl %edx, %eax
movq 0x10(%rsp), %rdx
movl %eax, 0x1c(%rsp)
movq %rsi, %rax
movl 0x1c(%rsp), %esi
movq %rax, 0x20(%rsp)
movq %rdi, %r8
movq 0x20(%rsp), %rdi
movb %r9b, %al
movq %r8, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movb %sil, 0x47(%rsp)
movq %rdx, 0x38(%rsp)
movb %cl, 0x37(%rsp)
movb %al, 0x36(%rsp)
movq 0x50(%rsp), %rax
movzbl 0xeb(%rax), %edx
movq 0x50(%rsp), %rax
movzbl 0xe6(%rax), %eax
xorl %eax, %edx
movq 0x50(%rsp), %rax
movzbl 0x121(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x121(%rax)
movq 0x50(%rsp), %rax
movzbl 0xc4(%rax), %edx
movq 0x50(%rsp), %rax
movzbl 0xc1(%rax), %eax
xorl %eax, %edx
movq 0x50(%rsp), %rax
movzbl 0xe6(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xe6(%rax)
movq 0x50(%rsp), %rax
movzbl 0xa0(%rax), %edx
movq 0x50(%rsp), %rax
movzbl 0x9a(%rax), %eax
xorl %eax, %edx
movq 0x50(%rsp), %rax
movzbl 0xc1(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xc1(%rax)
movq 0x50(%rsp), %rax
movzbl 0x6f(%rax), %edx
movq 0x50(%rsp), %rax
movzbl 0x6b(%rax), %eax
xorl %eax, %edx
movq 0x50(%rsp), %rax
movzbl 0x9a(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x9a(%rax)
movq 0x50(%rsp), %rax
movzbl 0x42(%rax), %edx
movq 0x50(%rsp), %rax
movzbl 0x3d(%rax), %eax
xorl %eax, %edx
movq 0x50(%rsp), %rax
movzbl 0x6b(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x6b(%rax)
movq 0x50(%rsp), %rax
movzbl 0x17(%rax), %edx
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
xorl %eax, %edx
movq 0x50(%rsp), %rax
movzbl 0x3d(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x3d(%rax)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movb 0x37(%rsp), %al
movzbl %al, %edx
movzbl 0x36(%rsp), %ecx
callq 0x1070
movb %al, 0x2f(%rsp)
movl $0x0, 0x30(%rsp)
cmpl $0x123, 0x30(%rsp)      # imm = 0x123
ja 0x16b3
movq 0x50(%rsp), %rax
movl 0x30(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x50(%rsp), %rax
movl 0x30(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x167f
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
movzbl 0x47(%rsp), %ecx
xorl %ecx, %eax
movb %al, %cl
movq 0x48(%rsp), %rax
movb %cl, (%rax)
movzbl 0x2f(%rsp), %eax
movq 0x48(%rsp), %rcx
movzbl (%rcx), %ecx
xorl %ecx, %eax
movb %al, %cl
movq 0x50(%rsp), %rax
movb %cl, 0x124(%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_enc_onebyte
void acorn128_enc_onebyte(unsigned char *state, unsigned char plaintextbyte,
       unsigned char *ciphertextbyte, unsigned char *ksbyte, unsigned char cabyte, unsigned char cbbyte)
{
    unsigned char i,t[4];
    unsigned char plaintextbit,ciphertextbit,kstem,ca,cb;

    *ciphertextbyte = 0;
    kstem = 0;
    *ksbyte = 0;
    for (i = 0; i < 8; i++)
    {
        ca = (cabyte >> i) & 1;
        cb = (cbbyte >> i) & 1;
        plaintextbit = (plaintextbyte >> i) & 1;
        Encrypt_StateUpdate128_1bit(state, plaintextbit, &ciphertextbit, &kstem, ca, cb);
        *ciphertextbyte |= (ciphertextbit << i);
        *ksbyte |= (kstem << i);
    }
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, %rax
movl 0x4(%rsp), %ecx
movq %rax, 0x8(%rsp)
movq %rdx, %rax
movq 0x8(%rsp), %rdx
movq %rax, 0x10(%rsp)
movl %esi, %eax
movq 0x10(%rsp), %rsi
movl %eax, 0x18(%rsp)
movq %rdi, %r8
movl 0x18(%rsp), %edi
movb %r9b, %al
movq %r8, 0x40(%rsp)
movb %dil, 0x3f(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movb %cl, 0x27(%rsp)
movb %al, 0x26(%rsp)
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movb $0x0, 0x1e(%rsp)
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
movb $0x0, 0x25(%rsp)
movzbl 0x25(%rsp), %eax
cmpl $0x8, %eax
jge 0x180e
movzbl 0x27(%rsp), %eax
movzbl 0x25(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0x1d(%rsp)
movzbl 0x26(%rsp), %eax
movzbl 0x25(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0x1c(%rsp)
movzbl 0x3f(%rsp), %eax
movzbl 0x25(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movb 0x20(%rsp), %sil
movb 0x1d(%rsp), %al
leaq 0x1f(%rsp), %rdx
leaq 0x1e(%rsp), %rcx
movzbl %sil, %esi
movzbl %al, %r8d
movzbl 0x1c(%rsp), %r9d
callq 0x10a0
movzbl 0x1f(%rsp), %edx
movzbl 0x25(%rsp), %ecx
shll %cl, %edx
movq 0x30(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movzbl 0x1e(%rsp), %edx
movzbl 0x25(%rsp), %ecx
shll %cl, %edx
movq 0x28(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movb 0x25(%rsp), %al
addb $0x1, %al
movb %al, 0x25(%rsp)
jmp 0x175d
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_dec_onebyte
void acorn128_dec_onebyte(unsigned char *state, unsigned char *plaintextbyte,
       unsigned char ciphertextbyte, unsigned char *ksbyte, unsigned char cabyte, unsigned char cbbyte)
{
    unsigned char i;
    unsigned char plaintextbit,ciphertextbit, ks,ca,cb;

    *plaintextbyte = 0;
    for  (i = 0; i < 8; i++)
    {
        ca = (cabyte >> i) & 1;
        cb = (cbbyte >> i) & 1;
        ciphertextbit = (ciphertextbyte >> i) & 1;
        Decrypt_StateUpdate128_1bit(state, &plaintextbit, ciphertextbit, &ks, ca, cb);
        *plaintextbyte |= (plaintextbit << i);
    }
}

// Assembly:
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, %rax
movl 0x4(%rsp), %ecx
movq %rax, 0x8(%rsp)
movl %edx, %eax
movq 0x8(%rsp), %rdx
movl %eax, 0x14(%rsp)
movq %rsi, %rax
movl 0x14(%rsp), %esi
movq %rax, 0x18(%rsp)
movq %rdi, %r8
movq 0x18(%rsp), %rdi
movb %r9b, %al
movq %r8, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movb %sil, 0x37(%rsp)
movq %rdx, 0x28(%rsp)
movb %cl, 0x27(%rsp)
movb %al, 0x26(%rsp)
movq 0x38(%rsp), %rax
movb $0x0, (%rax)
movb $0x0, 0x25(%rsp)
movzbl 0x25(%rsp), %eax
cmpl $0x8, %eax
jge 0x1917
movzbl 0x27(%rsp), %eax
movzbl 0x25(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0x21(%rsp)
movzbl 0x26(%rsp), %eax
movzbl 0x25(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0x20(%rsp)
movzbl 0x37(%rsp), %eax
movzbl 0x25(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0x23(%rsp)
movq 0x40(%rsp), %rdi
movb 0x23(%rsp), %dl
movb 0x21(%rsp), %al
leaq 0x24(%rsp), %rsi
leaq 0x22(%rsp), %rcx
movzbl %dl, %edx
movzbl %al, %r8d
movzbl 0x20(%rsp), %r9d
callq 0x1080
movzbl 0x24(%rsp), %edx
movzbl 0x25(%rsp), %ecx
shll %cl, %edx
movq 0x38(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movb 0x25(%rsp), %al
addb $0x1, %al
movb %al, 0x25(%rsp)
jmp 0x1880
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_initialization
void acorn128_initialization(const unsigned char *key, const unsigned char *iv, unsigned char *state)
{
        int i,j;
        unsigned char m[293], ks, tem;

        //initialize the state to 0
        for (j = 0; j <= 292; j++) state[j] = 0;

        //set the value of m
        for (j = 0; j <=  15;   j++)   m[j] = key[j];
        for (j = 16; j <= 31;   j++)   m[j] = iv[j - 16];
        for (j = 32; j <= 223;  j++)   m[j] = key[j & 0xf];
        m[32] ^= 1;

        //run the cipher for 1792 steps
        for (i = 0; i < 224; i++)
        {
             acorn128_enc_onebyte(state, m[i], &tem, &ks, 0xff, 0xff);
        }
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movl $0x0, 0x138(%rsp)
cmpl $0x124, 0x138(%rsp) # imm = 0x124
jg 0x197e
movq 0x140(%rsp), %rax
movslq 0x138(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x138(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x138(%rsp)
jmp 0x194a
movl $0x0, 0x138(%rsp)
cmpl $0xf, 0x138(%rsp)
jg 0x19c5
movq 0x150(%rsp), %rax
movslq 0x138(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0x138(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x138(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x138(%rsp)
jmp 0x1989
movl $0x10, 0x138(%rsp)
cmpl $0x1f, 0x138(%rsp)
jg 0x1a11
movq 0x148(%rsp), %rax
movl 0x138(%rsp), %ecx
subl $0x10, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq 0x138(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x138(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x138(%rsp)
jmp 0x19d0
movl $0x20, 0x138(%rsp)
cmpl $0xdf, 0x138(%rsp)
jg 0x1a60
movq 0x150(%rsp), %rax
movl 0x138(%rsp), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq 0x138(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x138(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x138(%rsp)
jmp 0x1a1c
movzbl 0x30(%rsp), %eax
xorl $0x1, %eax
movb %al, 0x30(%rsp)
movl $0x0, 0x13c(%rsp)
cmpl $0xe0, 0x13c(%rsp)
jge 0x1ac4
movq 0x140(%rsp), %rdi
movslq 0x13c(%rsp), %rax
leaq 0xe(%rsp), %rdx
leaq 0xf(%rsp), %rcx
movl $0xff, %r9d
movzbl 0x10(%rsp,%rax), %esi
movl %r9d, %r8d
callq 0x10d0
movl 0x13c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x13c(%rsp)
jmp 0x1a77
addq $0x158, %rsp            # imm = 0x158
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_tag_generation
void acorn128_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned char *state)
{
    int i;
    unsigned char plaintextbyte  = 0;
    unsigned char ciphertextbyte = 0;
    unsigned char ksbyte = 0;

    for (i = 0; i < 768/8; i++)
    {
        acorn128_enc_onebyte(state, plaintextbyte, &ciphertextbyte, &ksbyte, 0xff, 0xff);
        if ( i >= (768/8 - 16) ) {mac[i-(768/8-16)] = ksbyte; }
    }
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movb $0x0, 0xb(%rsp)
movb $0x0, 0xa(%rsp)
movb $0x0, 0x9(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x60, 0xc(%rsp)
jge 0x1b5a
movq 0x10(%rsp), %rdi
leaq 0xa(%rsp), %rdx
leaq 0x9(%rsp), %rcx
movl $0xff, %r9d
movzbl 0xb(%rsp), %esi
movl %r9d, %r8d
callq 0x10d0
cmpl $0x50, 0xc(%rsp)
jl 0x1b4b
movb 0x9(%rsp), %dl
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x50, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1b4d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b05
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::BasicBlock(unsigned long long, unsigned long long, Function*)
BasicBlock::BasicBlock(ADDR eip, ADDR vAddr, Function *func):
    hashNext(NULL), func(func), disasmed(false), disasm_pending(false)
    , visited(false)
{
    DISASM MyDisasm;
    memset(&MyDisasm, 0, sizeof(DISASM));
    MyDisasm.EIP = eip;
    MyDisasm.VirtualAddr = vAddr;
    MyDisasm.Archi = 64;
    MyDisasm.Options = ATSyntax|PrefixedNumeral|Tabulation;
    insts.push_back(MyDisasm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2d0(%rbp)
callq 0x8f70
movq -0x2d0(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x2e0(%rbp)
callq 0x8f90
movq -0x2d0(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x8f90
movq -0x2d0(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
movb $0x0, 0x58(%rax)
movb $0x0, 0x59(%rax)
movb $0x0, 0x5a(%rax)
leaq -0x2ad(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
xorl %esi, %esi
movl $0x28d, %edx            # imm = 0x28D
callq 0x80e0
movq -0x2d0(%rbp), %rdi
movq -0x2c8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x2ad(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x2a5(%rbp)
movl $0x40, -0x259(%rbp)
movq $0x10401, -0x255(%rbp) # imm = 0x10401
callq 0x8fb0
jmp 0x85d6
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
movq -0x2d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b8(%rbp)
movl %eax, -0x2bc(%rbp)
callq 0x9020
movq -0x2e0(%rbp), %rdi
callq 0x9020
movq -0x2d0(%rbp), %rdi
callq 0x9080
movq -0x2b8(%rbp), %rdi
callq 0x8320
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::dump() const
void BasicBlock::dump() const
{
    dumpBiref();
    for (ConstDisasmIter iter = insts.begin(); iter != insts.end(); iter++) {
    printf("\t\t\t0x%.8lx\t%s\n", iter->VirtualAddr, (char *)&iter->CompleteInstr);
    }
    puts("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8da0
movq -0x28(%rbp), %rdi
callq 0x93a0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9410
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x93d0
testb $0x1, %al
jne 0x8e26
jmp 0x8e6a
leaq -0x10(%rbp), %rdi
callq 0x9440
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9440
movq -0x30(%rbp), %rsi
movq %rax, %rdx
addq $0x14, %rdx
leaq 0x482bc(%rip), %rdi     # 0x5110e
movb $0x0, %al
callq 0x8030
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x9460
movq %rax, -0x20(%rbp)
jmp 0x8e06
leaq 0x483dd(%rip), %rdi     # 0x5124e
callq 0x82d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/binary.cpp
// Function: BinInfo::dumpFunc()
void BinInfo::dumpFunc()
{
    fprintf(stderr, "%-18s\t%-16s\t%-16s\t%-16s\t\n", "[Function Name]", "[Virtual Addr]", "[Map Start]", "[Map End]");
    char buf[128];
    for (FunctionIter iter = funcInfo.begin(); iter != funcInfo.end(); iter++) {
        fprintf(stderr, "%s\n", iter->toString(buf, sizeof(buf)));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq 0x54aef(%rip), %rax     # 0x61fd0
movq (%rax), %rdi
leaq 0x43d4a(%rip), %rsi     # 0x51235
leaq 0x43d5d(%rip), %rdx     # 0x5124f
leaq 0x43d66(%rip), %rcx     # 0x5125f
leaq 0x43d6e(%rip), %r8      # 0x5126e
leaq 0x43d73(%rip), %r9      # 0x5127a
movb $0x0, %al
callq 0x82a0
movq -0xb0(%rbp), %rdi
addq $0x38, %rdi
callq 0xd8b0
movq %rax, -0x98(%rbp)
movq -0xb0(%rbp), %rdi
addq $0x38, %rdi
callq 0xd920
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd8e0
testb $0x1, %al
jne 0xd555
jmp 0xd5b8
movq 0x54a74(%rip), %rax     # 0x61fd0
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xd950
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
movl $0x80, %edx
callq 0xea00
movq -0xb8(%rbp), %rdi
movq %rax, %rdx
leaq 0x43b82(%rip), %rsi     # 0x51119
movb $0x0, %al
callq 0x82a0
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0xd970
movq %rax, -0xa8(%rbp)
jmp 0xd525
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/binary.cpp
// Function: BinInfo::disasm()
void BinInfo::disasm()
{
    long pcount = 0;
    long bcount = 0;
    for (FunctionIter iter = funcInfo.begin(); iter != funcInfo.end(); iter++) {
        iter->disasm();
        //iter->dumpBiref();
        iter->reduction();
        iter->findCandidatePair();
        //iter->dumpBiref();
        pcount += iter->getCandidatePairs().size();
        bcount += iter->mergeBB();
#if 0
        const vector<BasicBlock *> vBB = iter->getBasicBlocks();
        for (BasicBlock::ConstBBPtrIter iter = vBB.begin(); iter != vBB.end(); iter++) {
            (*iter)->dump();
        }
#endif
    }
    printf("Count of Pairs: %ld\n", pcount);
    printf("Count of Equal Pairs: %ld\n", bcount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x38, %rdi
callq 0xd8b0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0xd920
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd8e0
testb $0x1, %al
jne 0xd628
jmp 0xd6a9
leaq -0x20(%rbp), %rdi
callq 0xd950
movq %rax, %rdi
callq 0xeb00
leaq -0x20(%rbp), %rdi
callq 0xd950
movq %rax, %rdi
callq 0xf240
leaq -0x20(%rbp), %rdi
callq 0xd950
movq %rax, %rdi
callq 0xf0c0
leaq -0x20(%rbp), %rdi
callq 0xd950
movq %rax, %rdi
callq 0xd9b0
movq %rax, %rdi
callq 0xd9d0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd950
movq %rax, %rdi
callq 0xeec0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xd970
movq %rax, -0x30(%rbp)
jmp 0xd601
movq -0x10(%rbp), %rsi
leaq 0x43bd0(%rip), %rdi     # 0x51284
movb $0x0, %al
callq 0x8030
movq -0x18(%rbp), %rsi
leaq 0x43bd3(%rip), %rdi     # 0x51299
movb $0x0, %al
callq 0x8030
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::Function(Function const&)
Function::Function (const Function &func)
{
    this->mapStart = func.mapStart;
    this->mapEnd = func.mapEnd;
    this->virStart = func.virStart;
    this->funcName = strdup(func.funcName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x20, %rdi
callq 0x8f90
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0xf3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::operator=(Function const&)
Function & Function::operator= (const Function &func)
{
    this->mapStart = func.mapStart;
    this->mapEnd = func.mapEnd;
    this->virStart = func.virStart;
    this->funcName = strdup(func.funcName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
ud2
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::getVirAddr(unsigned long long) const
ADDR Function::getVirAddr(ADDR mapAddr) const
{
    if (mapAddr <= mapEnd && mapAddr >= mapStart)
        return mapAddr - mapStart + virStart;
    else
        return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
ja 0xe990
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jb 0xe990
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq (%rcx), %rax
addq 0x10(%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0xe998
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::getMapAddr(unsigned long long) const
ADDR Function::getMapAddr(ADDR virAddr) const
{
    if (virAddr >=  virStart && virAddr <= virStart + mapEnd-mapStart)
        return virAddr-virStart+mapStart;
    else 
        return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x10(%rcx), %rax
jb 0xe9eb
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rdx), %rcx
addq 0x8(%rdx), %rcx
subq (%rdx), %rcx
cmpq %rcx, %rax
ja 0xe9eb
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq 0x10(%rcx), %rax
addq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0xe9f3
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::addBasicBlock(BasicBlock*)
void Function::addBasicBlock(BasicBlock *bb)
{
    ADDR addr = bb->getFirstInstAddr();
    BasicBlock *pos = hashTableBB[hash(addr)];
    if (!pos) {
        hashTableBB[hash((ADDR)bb)] = bb;
    } else {
        while (pos->getHashNext()) {
            pos = pos->getHashNext();
        }
        pos->setHashNext(bb);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9190
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0xf420
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x68(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xeac0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf420
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0xeaed
jmp 0xeac2
movq -0x20(%rbp), %rdi
callq 0xf440
cmpq $0x0, %rax
je 0xeae0
movq -0x20(%rbp), %rdi
callq 0xf440
movq %rax, -0x20(%rbp)
jmp 0xeac2
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::disasm()
void Function::disasm()
{
    //printf("\tStart Function::disasm %s\n", funcName);
    queue<BasicBlock *> que;
    BasicBlock *bb = findBasicBlock(mapStart);
    que.push(bb);
    bb->setDisasmPending(true);
    while (!que.empty()) {
        bb = que.front();
        bb->disasm();
        const vector<BasicBlock *> &succ = bb->getSuccessors();
        for (BasicBlock::ConstBBPtrIter iter = succ.begin(); iter != succ.end(); iter++) {
            if ((*iter)->isDisasmed() || (*iter)->isDisasmPending())
                continue;
            que.push(*iter);
            (*iter)->setDisasmPending(true);
        }
        que.pop();
        bb->setDisasmPending(false);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xf480
movq -0xa0(%rbp), %rdi
movq (%rdi), %rsi
callq 0xecf0
movq %rax, -0x98(%rbp)
jmp 0xeb3b
movq -0x98(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xf4b0
jmp 0xeb55
movq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0xf4e0
jmp 0xeb65
jmp 0xeb67
leaq -0x58(%rbp), %rdi
callq 0xf500
movb %al, -0xa1(%rbp)
jmp 0xeb78
movb -0xa1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xeb89
jmp 0xeccf
leaq -0x58(%rbp), %rdi
callq 0xf520
movq %rax, -0xb0(%rbp)
jmp 0xeb9b
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x8630
jmp 0xebb4
movq -0x60(%rbp), %rdi
callq 0x95e0
movq %rax, -0xb8(%rbp)
jmp 0xebc6
movq -0xb8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x92a0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x9310
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x92d0
testb $0x1, %al
jne 0xec07
jmp 0xecb2
leaq -0x80(%rbp), %rdi
callq 0x9340
movq (%rax), %rdi
callq 0x90e0
movb %al, -0xb9(%rbp)
jmp 0xec20
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0xec51
jmp 0xec2c
leaq -0x80(%rbp), %rdi
callq 0x9340
movq (%rax), %rdi
callq 0xf540
movb %al, -0xba(%rbp)
jmp 0xec45
movb -0xba(%rbp), %al
testb $0x1, %al
jne 0xec51
jmp 0xec6a
jmp 0xec9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xf580
jmp 0xece1
leaq -0x80(%rbp), %rdi
callq 0x9340
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xf4b0
jmp 0xec81
leaq -0x80(%rbp), %rdi
callq 0x9340
movq (%rax), %rdi
movl $0x1, %esi
callq 0xf4e0
jmp 0xec99
jmp 0xec9b
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x9360
movq %rax, -0x90(%rbp)
jmp 0xebde
leaq -0x58(%rbp), %rdi
callq 0xf560
jmp 0xecbd
movq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0xf4e0
jmp 0xecca
jmp 0xeb67
leaq -0x58(%rbp), %rdi
callq 0xf580
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8320
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::findBasicBlock(unsigned long long)
BasicBlock *Function::findBasicBlock(ADDR addr)
{
    BasicBlock *pos = hashTableBB[hash(addr)];
    while (pos) {
        if (pos->getFirstInstAddr() == getVirAddr(addr))
            break;
        pos = pos->getHashNext();
    }

    if (!pos) {
        pos = new BasicBlock(addr, getVirAddr(addr), this);
        basicBlocks.push_back(pos);
        BasicBlock *bb = hashTableBB[hash(addr)];
        pos->setHashNext(bb);
        hashTableBB[hash(addr)] = pos;
    }
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf420
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x68(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xed5f
movq -0x18(%rbp), %rdi
callq 0x9190
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe950
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0xed50
jmp 0xed5f
movq -0x18(%rbp), %rdi
callq 0xf440
movq %rax, -0x18(%rbp)
jmp 0xed21
cmpq $0x0, -0x18(%rbp)
jne 0xee29
movl $0x60, %edi
callq 0x81e0
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
callq 0xe950
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq %rax, %rdx
callq 0x8500
jmp 0xeda3
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0x91c0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf420
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x68(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf460
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf420
movq -0x60(%rbp), %rdx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0xee29
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x81f0
jmp 0xee33
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8320
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::mergeBB()
long Function::mergeBB()
{
    long count = 0;
    for (set<BasicBlock *>::iterator iter = pairBBs.begin(); iter!=pairBBs.end(); iter++) {
        BasicBlock* bbptr = *iter;
        
        assert(bbptr->getSuccessors().size() == 2);
        TaintBlock *left = new TaintBlock(bbptr->getSuccessors().front());
        TaintBlock *right = new TaintBlock(bbptr->getSuccessors().back());
        if (*left == *right) {
            bbptr->dump();
            left->dump();
            bbptr->getSuccessors().front()->dump();
            right->dump();
            bbptr->getSuccessors().back()->dump();
            count++;
        }
        free(left);
        free(right);
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq $0x0, -0x10(%rbp)
addq $0x38, %rdi
callq 0xf5a0
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
callq 0xf600
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf5d0
testb $0x1, %al
jne 0xef13
jmp 0xf0a2
leaq -0x18(%rbp), %rdi
callq 0xf630
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x95e0
movq %rax, %rdi
callq 0xa790
cmpq $0x2, %rax
jne 0xef3c
jmp 0xef5b
leaq 0x42404(%rip), %rdi     # 0x51347
leaq 0x42420(%rip), %rsi     # 0x5136a
movl $0x7f, %edx
leaq 0x42425(%rip), %rcx     # 0x5137b
callq 0x8120
movl $0xe0, %edi
callq 0x81e0
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x95e0
movq %rax, -0x60(%rbp)
jmp 0xef78
movq -0x60(%rbp), %rdi
callq 0xf660
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
callq 0x13440
jmp 0xef8f
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0xe0, %edi
callq 0x81e0
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rdi
callq 0x95e0
movq %rax, -0x70(%rbp)
jmp 0xefb4
movq -0x70(%rbp), %rdi
callq 0xf690
movq -0x78(%rbp), %rdi
movq (%rax), %rsi
callq 0x13440
jmp 0xefcb
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x133b0
testb $0x1, %al
jne 0xefe9
jmp 0xf07c
movq -0x28(%rbp), %rdi
callq 0x8de0
movq -0x30(%rbp), %rdi
callq 0x13fc0
movq -0x28(%rbp), %rdi
callq 0x95e0
movq %rax, %rdi
callq 0xf660
movq (%rax), %rdi
callq 0x8de0
movq -0x48(%rbp), %rdi
callq 0x13fc0
movq -0x28(%rbp), %rdi
callq 0x95e0
movq %rax, %rdi
callq 0xf690
movq (%rax), %rdi
callq 0x8de0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf07c
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0xe0, %esi
callq 0x81f0
jmp 0xf0af
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0xe0, %esi
callq 0x81f0
jmp 0xf0af
movq -0x30(%rbp), %rdi
callq 0x8270
movq -0x48(%rbp), %rdi
callq 0x8270
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xf6d0
movq %rax, -0x50(%rbp)
jmp 0xeeec
movq -0x10(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8320
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::findCandidatePair()
void Function::findCandidatePair()
{
   // for (BasicBlock::ConstRevBBPtrIter iter = leafBBs.rbegin(); iter!=leafBBs.rend(); iter++) {
    for (BasicBlock::BBPtrIter iter = basicBlocks.begin(); iter!=basicBlocks.end(); iter++) {
        BasicBlock* bbptr = *iter;
        if (!bbptr->isLeaf())
            continue;
        if (bbptr->isVisited())
            continue;
        const vector<BasicBlock *> preds = bbptr->getPredecessors();
        if (preds.size() != 1)
            continue;
        BasicBlock *pred = preds.front();
        if (pred->getSuccessors().size() != 2)
            continue;
        pairBBs.insert(pred);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x20, %rdi
callq 0xa690
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x9570
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xf710
testb $0x1, %al
jne 0xf10b
jmp 0xf224
leaq -0x10(%rbp), %rdi
callq 0xf750
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf770
testb $0x1, %al
jne 0xf12d
jmp 0xf210
movq -0x20(%rbp), %rdi
callq 0xf7a0
testb $0x1, %al
jne 0xf13c
jmp 0xf141
jmp 0xf210
movq -0x20(%rbp), %rdi
callq 0xf7c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xf7e0
leaq -0x38(%rbp), %rdi
callq 0xa790
cmpq $0x1, %rax
je 0xf171
movl $0x4, -0x3c(%rbp)
jmp 0xf1fa
leaq -0x38(%rbp), %rdi
callq 0xf660
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x95e0
movq %rax, -0x80(%rbp)
jmp 0xf190
movq -0x80(%rbp), %rdi
callq 0xa790
cmpq $0x2, %rax
je 0xf1bf
movl $0x4, -0x3c(%rbp)
jmp 0xf1fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9020
jmp 0xf22d
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
leaq -0x48(%rbp), %rsi
callq 0xf8d0
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0xf1df
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9020
movl -0x3c(%rbp), %eax
testl %eax, %eax
je 0xf20e
jmp 0xf20c
jmp 0xf210
jmp 0xf210
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xf920
movq %rax, -0x70(%rbp)
jmp 0xf0e4
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8320
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/function.cpp
// Function: Function::reduction()
void Function::reduction()
{
    bool change = false;
    do {
        change = false;
        for (BasicBlock::BBPtrIter iter = basicBlocks.begin(); iter!=basicBlocks.end(); iter++) {
            BasicBlock* bbptr = *iter;
            if (bbptr->isRemoved()) {
                basicBlocks.erase(iter);
                break;
            }
            const vector<BasicBlock *> succs = bbptr->getSuccessors();
            if (succs.size() != 1)
                continue;
            BasicBlock *succ = succs.front();
            if (succ->getPredecessors().size() != 1)
                continue;
            
            bbptr->merge(succ);
            succ->setRemoved(true);
            change = true;
        }
    } while (change);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x80(%rbp), %rdi
movb $0x0, -0x9(%rbp)
addq $0x20, %rdi
callq 0xa690
movq %rax, -0x18(%rbp)
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
callq 0x9570
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf710
testb $0x1, %al
jne 0xf297
jmp 0xf3c0
leaq -0x18(%rbp), %rdi
callq 0xf750
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf960
testb $0x1, %al
jne 0xf2b6
jmp 0xf2eb
movq -0x80(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x95a0
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf980
movq %rax, -0x38(%rbp)
jmp 0xf3c0
movq -0x28(%rbp), %rdi
callq 0x95e0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0xf7e0
leaq -0x50(%rbp), %rdi
callq 0xa790
cmpq $0x1, %rax
je 0xf318
movl $0x6, -0x54(%rbp)
jmp 0xf396
leaq -0x50(%rbp), %rdi
callq 0xf660
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xf7c0
movq %rax, -0x90(%rbp)
jmp 0xf33a
movq -0x90(%rbp), %rdi
callq 0xa790
cmpq $0x1, %rax
je 0xf36c
movl $0x6, -0x54(%rbp)
jmp 0xf396
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9020
jmp 0xf3d5
movq -0x28(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x8e80
jmp 0xf37b
movq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0xf9f0
jmp 0xf38b
movb $0x1, -0x9(%rbp)
movl $0x0, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9020
movl -0x54(%rbp), %eax
testl %eax, %eax
je 0xf3aa
jmp 0xf3a8
jmp 0xf3ac
jmp 0xf3ac
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xf920
movq %rax, -0x78(%rbp)
jmp 0xf270
jmp 0xf3c2
testb $0x1, -0x9(%rbp)
jne 0xf25b
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8320
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/src/main.cpp
// Function: main
int main(int argc, char* argv [])
{
    // 1.judge illegal
    if(argc<=1){
        fprintf(stderr, "Usage: ./rop FileList\n");
        abort();
    }
    // 2.read file List and find Ret Code
    vector<BinInfo> vBin;
    puts("[1] BinInfo parse");
    for(int i=1; i<argc; i++){
        BinInfo bin(argv[i]);
        //bin.findRetCodeInElf();
        vBin.push_back(bin);
    }

#if 0
    puts("");
    puts("[2] Dump Function Information");
    for (vector<BinInfo>::iterator iter = vBin.begin(); iter != vBin.end(); iter++) {
        iter->dumpFunc();
    }
#endif
    puts("");
    puts("[2] Disasm Function");
    for (vector<BinInfo>::iterator iter = vBin.begin(); iter != vBin.end(); iter++) {
        iter->disasm();
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x11d5c
movq 0x5028a(%rip), %rax     # 0x61fd0
movq (%rax), %rdi
leaq 0x3f674(%rip), %rsi     # 0x513c4
movb $0x0, %al
callq 0x82a0
callq 0x80f0
leaq -0x28(%rbp), %rdi
callq 0x11eb0
leaq 0x3f66f(%rip), %rdi     # 0x513db
callq 0x82d0
jmp 0x11d73
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11df3
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x90(%rbp), %rdi
callq 0xce20
jmp 0x11d9c
leaq -0x28(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11ed0
jmp 0x11dae
leaq -0x90(%rbp), %rdi
callq 0x11f40
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x11d7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x11e93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x11f40
jmp 0x11e93
leaq 0x3f454(%rip), %rdi     # 0x5124e
callq 0x82d0
jmp 0x11e01
leaq 0x3f5e5(%rip), %rdi     # 0x513ed
callq 0x82d0
jmp 0x11e0f
leaq -0x28(%rbp), %rdi
callq 0x11f70
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11fe0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x11fa0
testb $0x1, %al
jne 0x11e48
jmp 0x11e77
leaq -0x98(%rbp), %rdi
callq 0x12010
movq %rax, %rdi
callq 0xd5d0
jmp 0x11e5e
jmp 0x11e60
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0x12030
movq %rax, -0xa8(%rbp)
jmp 0x11e1f
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12070
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x12070
movq -0x30(%rbp), %rdi
callq 0x8320
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_EbGb
void __bea_callspec__ add_EbGb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1dc(%rax), %eax
cmpl $0x4, %eax
jne 0x15cc7
movq -0x8(%rbp), %rax
movb $0x1, 0x1dc(%rax)
movq -0x8(%rbp), %rax
movl $0x10002, 0x60(%rax)    # imm = 0x10002
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x3bdf0(%rip), %rsi     # 0x51ad5
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4d4d0
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_EvGv
void __bea_callspec__ add_EvGv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1dc(%rax), %eax
cmpl $0x4, %eax
jne 0x15d37
movq -0x8(%rbp), %rax
movb $0x1, 0x1dc(%rax)
movq -0x8(%rbp), %rax
movl $0x10002, 0x60(%rax)    # imm = 0x10002
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x3bd80(%rip), %rsi     # 0x51ad5
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4d5a0
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_GbEb
void __bea_callspec__ add_GbEb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1dc(%rax), %eax
cmpl $0x4, %eax
jne 0x15da7
movq -0x8(%rbp), %rax
movb $0x1, 0x1dc(%rax)
movq -0x8(%rbp), %rax
movl $0x10002, 0x60(%rax)    # imm = 0x10002
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x3bd10(%rip), %rsi     # 0x51ad5
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4d650
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_GvEv
void __bea_callspec__ add_GvEv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1dc(%rax), %eax
cmpl $0x4, %eax
jne 0x15e17
movq -0x8(%rbp), %rax
movb $0x1, 0x1dc(%rax)
movq -0x8(%rbp), %rax
movl $0x10002, 0x60(%rax)    # imm = 0x10002
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x3bca0(%rip), %rsi     # 0x51ad5
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4d6e0
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_ALIb
void __bea_callspec__ add_ALIb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1dc(%rax), %eax
cmpl $0x4, %eax
jne 0x15e87
movq -0x8(%rbp), %rax
movb $0x1, 0x1dc(%rax)
movq -0x8(%rbp), %rax
movl $0x10002, 0x60(%rax)    # imm = 0x10002
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x3bc30(%rip), %rsi     # 0x51ad5
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4d790
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)