LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: read_plain_text_ext(gd_GIF*)
static void
read_plain_text_ext(gd_GIF *gif)
{
    if (gif->plain_text) {
        uint16_t tx, ty, tw, th;
        uint8_t cw, ch, fg, bg;
        off_t sub_block;
        lseek(gif->fd, 1, SEEK_CUR); /* block size = 12 */
        tx = read_num(gif->fd);
        ty = read_num(gif->fd);
        tw = read_num(gif->fd);
        th = read_num(gif->fd);
        read(gif->fd, &cw, 1);
        read(gif->fd, &ch, 1);
        read(gif->fd, &fg, 1);
        read(gif->fd, &bg, 1);
        sub_block = lseek(gif->fd, 0, SEEK_CUR);
        gif->plain_text(gif, tx, ty, tw, th, cw, ch, fg, bg);
        lseek(gif->fd, sub_block, SEEK_SET);
    } else {
        /* Discard plain text metadata. */
        lseek(gif->fd, 13, SEEK_CUR);
    }
    /* Discard plain text sub-blocks. */
    discard_sub_blocks(gif);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x638(%rax)
je 0x448c1
movq 0x30(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x36d0
movq 0x30(%rsp), %rax
movl (%rax), %edi
callq 0x3b250
movw %ax, 0x2e(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %edi
callq 0x3b250
movw %ax, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %edi
callq 0x3b250
movw %ax, 0x2a(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %edi
callq 0x3b250
movw %ax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %edi
leaq 0x27(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movq 0x30(%rsp), %rax
movl (%rax), %edi
leaq 0x26(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movq 0x30(%rsp), %rax
movl (%rax), %edi
leaq 0x25(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movq 0x30(%rsp), %rax
movl (%rax), %edi
leaq 0x24(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movq 0x30(%rsp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x36d0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x638(%rax), %rax
movq 0x30(%rsp), %rdi
movw 0x2e(%rsp), %si
movw 0x2c(%rsp), %dx
movw 0x2a(%rsp), %cx
movw 0x28(%rsp), %r8w
movb 0x27(%rsp), %r9b
movb 0x26(%rsp), %r11b
movb 0x25(%rsp), %r10b
movzwl %si, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %r8w, %r8d
movzbl %r9b, %r9d
movzbl %r11b, %r11d
movl %r11d, (%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x8(%rsp)
movzbl 0x24(%rsp), %r10d
movl %r10d, 0x10(%rsp)
callq *%rax
movq 0x30(%rsp), %rax
movl (%rax), %edi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x36d0
jmp 0x448d7
movq 0x30(%rsp), %rax
movl (%rax), %edi
movl $0xd, %esi
movl $0x1, %edx
callq 0x36d0
movq 0x30(%rsp), %rdi
callq 0x44b50
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: read_graphic_control_ext(gd_GIF*)
static void
read_graphic_control_ext(gd_GIF *gif)
{
    uint8_t rdit;

    /* Discard block size (always 0x04). */
    lseek(gif->fd, 1, SEEK_CUR);
    read(gif->fd, &rdit, 1);
    gif->gce.disposal = (rdit >> 2) & 3;
    gif->gce.input = rdit & 2;
    gif->gce.transparency = rdit & 1;
    gif->gce.delay = read_num(gif->fd);
    read(gif->fd, &gif->gce.tindex, 1);
    /* Skip block terminator. */
    lseek(gif->fd, 1, SEEK_CUR);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x36d0
movq 0x10(%rsp), %rax
movl (%rax), %edi
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movzbl 0xf(%rsp), %eax
sarl $0x2, %eax
andl $0x3, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1b(%rax)
movzbl 0xf(%rsp), %ecx
andl $0x2, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movzbl 0xf(%rsp), %ecx
andl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x3b250
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
addq $0x2, %rsi
movl $0x1, %edx
callq 0x3520
movq 0x10(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x36d0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: read_comment_ext(gd_GIF*)
static void
read_comment_ext(gd_GIF *gif)
{
    if (gif->comment) {
        off_t sub_block = lseek(gif->fd, 0, SEEK_CUR);
        gif->comment(gif);
        lseek(gif->fd, sub_block, SEEK_SET);
    }
    /* Discard comment sub-blocks. */
    discard_sub_blocks(gif);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x640(%rax)
je 0x44a08
movq 0x10(%rsp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x36d0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x640(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x36d0
movq 0x10(%rsp), %rdi
callq 0x44b50
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: read_application_ext(gd_GIF*)
static void
read_application_ext(gd_GIF *gif)
{
    char app_id[8];
    char app_auth_code[3];

    /* Discard block size (always 0x0B). */
    lseek(gif->fd, 1, SEEK_CUR);
    /* Application Identifier. */
    read(gif->fd, app_id, 8);
    /* Application Authentication Code. */
    read(gif->fd, app_auth_code, 3);
    if (!strncmp(app_id, "NETSCAPE", sizeof(app_id))) {
        /* Discard block size (0x03) and constant byte (0x01). */
        lseek(gif->fd, 2, SEEK_CUR);
        gif->loop_count = read_num(gif->fd);
        /* Skip block terminator. */
        lseek(gif->fd, 1, SEEK_CUR);
    } else if (gif->application) {
        off_t sub_block = lseek(gif->fd, 0, SEEK_CUR);
        gif->application(gif, app_id, app_auth_code);
        lseek(gif->fd, sub_block, SEEK_SET);
        discard_sub_blocks(gif);
    } else {
        discard_sub_blocks(gif);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x36d0
movq 0x20(%rsp), %rax
movl (%rax), %edi
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
callq 0x3520
movq 0x20(%rsp), %rax
movl (%rax), %edi
leaq 0x15(%rsp), %rsi
movl $0x3, %edx
callq 0x3520
leaq 0x18(%rsp), %rdi
leaq 0x4e3c(%rip), %rsi      # 0x498b3
movl $0x8, %edx
callq 0x31c0
cmpl $0x0, %eax
jne 0x44acc
movq 0x20(%rsp), %rax
movl (%rax), %edi
movl $0x2, %esi
movl $0x1, %edx
callq 0x36d0
movq 0x20(%rsp), %rax
movl (%rax), %edi
callq 0x3b250
movw %ax, %cx
movq 0x20(%rsp), %rax
movw %cx, 0x16(%rax)
movq 0x20(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0x36d0
jmp 0x44b3d
movq 0x20(%rsp), %rax
cmpq $0x0, 0x648(%rax)
je 0x44b31
movq 0x20(%rsp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x36d0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x648(%rax), %rax
movq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x15(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x36d0
movq 0x20(%rsp), %rdi
callq 0x44b50
jmp 0x44b3b
movq 0x20(%rsp), %rdi
callq 0x44b50
jmp 0x44b3d
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: new_table(int)
static Table *
new_table(int key_size)
{
    int key;
    int init_bulk = MAX(1 << (key_size + 1), 0x100);
    Table *table = (Table *) malloc(sizeof(*table) + sizeof(Entry) * init_bulk);
    if (table) {
        table->bulk = init_bulk;
        table->nentries = (1 << key_size) + 2;
        table->entries = (Entry *) &table[1];
        for (key = 0; key < (1 << key_size); key++)
            table->entries[key] = (Entry) {1, 0xFFF, (uint8_t) key};
    }
    return table;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl $0x100, %eax            # imm = 0x100
jle 0x44f51
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x4(%rsp)
jmp 0x44f5c
movl $0x100, %eax            # imm = 0x100
movl %eax, 0x4(%rsp)
jmp 0x44f5c
movl 0x4(%rsp), %eax
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
imulq $0x6, %rax, %rdi
addq $0x10, %rdi
callq 0x34c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x45022
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x24(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
addl $0x2, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rcx
addq $0x10, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x45020
movw $0x1, 0xa(%rsp)
movw $0xfff, 0xc(%rsp)       # imm = 0xFFF
movl 0x20(%rsp), %eax
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x20(%rsp), %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movl 0xa(%rsp), %ecx
movl %ecx, (%rax)
movw 0xe(%rsp), %cx
movw %cx, 0x4(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x44fc4
jmp 0x45022
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: get_key(gd_GIF*, int, unsigned char*, unsigned char*, unsigned char*)
static uint16_t
get_key(gd_GIF *gif, int key_size, uint8_t *sub_len, uint8_t *shift, uint8_t *byte)
{
    int bits_read;
    int rpad;
    int frag_size;
    uint16_t key;

    key = 0;
    for (bits_read = 0; bits_read < key_size; bits_read += frag_size) {
        rpad = (*shift + bits_read) % 8;
        if (rpad == 0) {
            /* Update byte. */
            if (*sub_len == 0)
                read(gif->fd, sub_len, 1); /* Must be nonzero! */
            read(gif->fd, byte, 1);
            (*sub_len)--;
        }
        frag_size = MIN(key_size - bits_read, 8 - rpad);
        key |= ((uint16_t) ((*byte) >> rpad)) << bits_read;
    }
    /* Clear extra bits to the left. */
    key &= (1 << key_size) - 1;
    *shift = (*shift + key_size) % 8;
    return key;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movw $0x0, 0x12(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x4513b
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
addl 0x1c(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x450cd
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x450ab
movq 0x40(%rsp), %rax
movl (%rax), %edi
movq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movq 0x40(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x3520
movq 0x30(%rsp), %rax
movb (%rax), %cl
addb $-0x1, %cl
movb %cl, (%rax)
movl 0x3c(%rsp), %eax
subl 0x1c(%rsp), %eax
movl $0x8, %ecx
subl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x450f0
movl 0x3c(%rsp), %eax
subl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x450fd
movl $0x8, %eax
subl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
movl 0x18(%rsp), %ecx
sarl %cl, %eax
movzwl %ax, %eax
movl 0x1c(%rsp), %ecx
shll %cl, %eax
movl %eax, %ecx
movzwl 0x12(%rsp), %eax
orl %ecx, %eax
movw %ax, 0x12(%rsp)
movl 0x14(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x4505b
movl 0x3c(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movzwl 0x12(%rsp), %eax
andl %ecx, %eax
movw %ax, 0x12(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
addl 0x3c(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movb %dl, %cl
movq 0x28(%rsp), %rax
movb %cl, (%rax)
movw 0x12(%rsp), %ax
addq $0x48, %rsp
retq
nop
// File: cloudinary[P]fuif/./import/read_gif.h
// Function: add_entry(Table**, unsigned short, unsigned short, unsigned char)
static int
add_entry(Table **tablep, uint16_t length, uint16_t prefix, uint8_t suffix)
{
    Table *table = *tablep;
    if (table->nentries == table->bulk) {
        table->bulk *= 2;
        table = (Table*) realloc(table, sizeof(*table) + sizeof(Entry) * table->bulk);
        if (!table) return -1;
        table->entries = (Entry *) &table[1];
        *tablep = table;
    }
    table->entries[table->nentries] = (Entry) {length, prefix, suffix};
    table->nentries++;
    if ((table->nentries & (table->nentries - 1)) == 0)
        return 1;
    return 0;
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movw %dx, %cx
movw %si, %dx
movq %rdi, 0x18(%rsp)
movw %dx, 0x16(%rsp)
movw %cx, 0x14(%rsp)
movb %al, 0x13(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x4521b
movq 0x8(%rsp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rax
imulq $0x6, %rax, %rsi
addq $0x10, %rsi
callq 0x3630
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x451fc
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x45299
movq 0x8(%rsp), %rcx
addq $0x10, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movw 0x16(%rsp), %ax
movw %ax, 0x2(%rsp)
movw 0x14(%rsp), %ax
movw %ax, 0x4(%rsp)
movb 0x13(%rsp), %al
movb %al, 0x6(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movl 0x2(%rsp), %ecx
movl %ecx, (%rax)
movw 0x6(%rsp), %cx
movw %cx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x45291
movl $0x1, 0x24(%rsp)
jmp 0x45299
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: msotoodeh[P]asymmetric-passwords/demo/demo.cpp
// Function: GetErrorString(int)
const char* GetErrorString(int err)
{
    switch (err)
    {
    case APVerifier::AP_SUCCESS     : return "SUCCESS";
    case APVerifier::AP_E_PARAMETER : return "Invalid parameter";
    case APVerifier::AP_E_FORMAT    : return "Invalid format";
    case APVerifier::AP_E_KEY       : return "Invalid key";
    case APVerifier::AP_E_ALGO      : return "Invalid/Unknown algorithm";
    case APVerifier::AP_E_TOKEN     : return "Invalid token";
    case APVerifier::AP_E_TIMESTAMP : return "Invalid timestamp";
    case APVerifier::AP_E_SIZE      : return "Item too short";
    case APVerifier::AP_E_B64_ITEM  : return "Invalid base64 item";
    case APVerifier::AP_E_SIGNATURE : return "Signature mismatch";
    case APVerifier::AP_E_EMPTY     : return "Item is empty";
    case APVerifier::AP_E_TIME      : return "Token time out of valid range";
    case APVerifier::AP_E_EXPIRED   : return "Token time expired";
    }
    return "Unexpected error code";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0xc, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xc, %eax
ja 0x404545
movq -0x18(%rbp), %rax
leaq 0x17cb89(%rip), %rcx    # 0x581010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x17ccb9(%rip), %rax    # 0x581150
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccb1(%rip), %rax    # 0x581158
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccb3(%rip), %rax    # 0x58116a
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccb2(%rip), %rax    # 0x581179
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccae(%rip), %rax    # 0x581185
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccbb(%rip), %rax    # 0x58119f
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccbc(%rip), %rax    # 0x5811ad
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccc1(%rip), %rax    # 0x5811bf
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccc3(%rip), %rax    # 0x5811ce
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccca(%rip), %rax    # 0x5811e2
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccd0(%rip), %rax    # 0x5811f5
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17ccd1(%rip), %rax    # 0x581203
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17cce2(%rip), %rax    # 0x581221
movq %rax, -0x8(%rbp)
jmp 0x404550
leaq 0x17cce8(%rip), %rax    # 0x581234
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/demo/demo.cpp
// Function: tag_name(unsigned int)
const char* tag_name(unsigned int tag)
{
    switch (tag)
    {
    case AP_NEW_USER: 
        return "REGISTER NEW USER";
    case AP_USER_LOGIN:
        return "LOGIN";
    case AP_CHANGE_PASSWORD:
        return "CHANGE PASSWORD";
    case AP_RESET_PASSWORD:
        return "PASSWORD RESET";
    case AP_UPDATE_TOKEN:
        return "TOKEN UPDATE";
    case AP_CHALLENGE_RESPONSE:
        return "CHALLENGED RESPONSE";
    }
    return "???";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x6370, %eax           # imm = 0x6370
je 0x40462c
jmp 0x4045d6
movl -0x10(%rbp), %eax
subl $0x6372, %eax           # imm = 0x6372
je 0x404653
jmp 0x4045e2
movl -0x10(%rbp), %eax
subl $0x6c69, %eax           # imm = 0x6C69
je 0x40461f
jmp 0x4045ee
movl -0x10(%rbp), %eax
subl $0x6e75, %eax           # imm = 0x6E75
je 0x404612
jmp 0x4045fa
movl -0x10(%rbp), %eax
subl $0x7270, %eax           # imm = 0x7270
je 0x404639
jmp 0x404606
movl -0x10(%rbp), %eax
subl $0x7574, %eax           # imm = 0x7574
je 0x404646
jmp 0x404660
leaq 0x17cc58(%rip), %rax    # 0x581271
movq %rax, -0x8(%rbp)
jmp 0x40466b
leaq 0x17cc5d(%rip), %rax    # 0x581283
movq %rax, -0x8(%rbp)
jmp 0x40466b
leaq 0x17cc56(%rip), %rax    # 0x581289
movq %rax, -0x8(%rbp)
jmp 0x40466b
leaq 0x17cc59(%rip), %rax    # 0x581299
movq %rax, -0x8(%rbp)
jmp 0x40466b
leaq 0x17cc5b(%rip), %rax    # 0x5812a8
movq %rax, -0x8(%rbp)
jmp 0x40466b
leaq 0x17cc5b(%rip), %rax    # 0x5812b5
movq %rax, -0x8(%rbp)
jmp 0x40466b
leaq 0x17cc62(%rip), %rax    # 0x5812c9
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/demo/demo.cpp
// Function: print_verifier_state(APVerifier&)
void print_verifier_state(APVerifier& v)
{
    printf(" Status(%s): %s\n", tag_name(v.getTag()), GetErrorString(v.getError()));
    if (v.getError() != APVerifier::AP_SUCCESS) 
    {
        return;
    }

    print_time_value(" token timestamp ... :", v.getTimestamp());
    /*
    size_t i, nItems = v.getItemCount();
    for (i = 0; i < nItems; i++)
    {
        printf(" %d - [%s]\n", (int)i, v.getItem(i).c_str());
    }
    printf("\n public key (verifier): %s\n", v.getPublicKey().c_str());
    */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x405910
movl %eax, %edi
callq 0x4045c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x405930
movl %eax, %edi
callq 0x404460
movq -0x10(%rbp), %rsi
movq %rax, %rdx
leaq 0x17cc0f(%rip), %rdi    # 0x5812cd
movb $0x0, %al
callq 0x4d79b0
movq -0x8(%rbp), %rdi
callq 0x405930
cmpl $0x0, %eax
je 0x4046d5
jmp 0x4046ed
movq -0x8(%rbp), %rdi
callq 0x405950
movq %rax, %rsi
leaq 0x17cbf6(%rip), %rdi    # 0x5812de
callq 0x404560
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APKeyDerivation.cpp
// Function: APDigest::finish(void*, unsigned long)
size_t APDigest::finish(void* digest, size_t size)
{
    SHA512_Final(m_Digest, &m_Ctx);
    if (size > DIGEST_SIZE) 
        size = DIGEST_SIZE;

    memcpy(digest, &m_Digest[0], size);
    return size;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
addq $0xd8, %rdi
callq 0x40bcf0
cmpq $0x40, 0x10(%rsp)
jbe 0x4073cd
movq $0x40, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0xd8, %rsi
movq 0x10(%rsp), %rdx
callq 0x401108
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APKeyDerivation.cpp
// Function: APDigest::kdf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char*, unsigned long)
void APDigest::kdf(
    const std::string& userid,
    const std::string& password,
    const std::string& domain,
    uint8_t* dk, size_t dkLen)
{
#ifdef USE_PASSWORD_HASH
    // Replace password with its hash to be able to convert hashed
    // passwords automatically

    // Here we are assuming passwords are haded with sha512
    APDigest passwordHash(password.c_str(), password.length());

    // Use combination of userid & domain as salt

    APDigest saltHash;
    saltHash.update(userid.c_str(), userid.length());
    saltHash.update(&kdf_separator, 1);
    saltHash.update(domain.c_str(), domain.length());
    saltHash.finish();

    APDigest::pbkdf2(
        passwordHash.digest(), APDigest::DIGEST_SIZE, 
        saltHash.digest(), APDigest::DIGEST_SIZE,
        APDigest::KDF_ITERATIONS,
        dk, dkLen);
#else
    std::string salt = userid + AP_KDF_SEP + domain;
    APDigest::pbkdf2(
        password.c_str(), password.length(), 
        salt.c_str(), salt.length(),
        APDigest::KDF_ITERATIONS,
        dk, dkLen);
#endif
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0xa0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x26, %edx
callq 0x407b30
movq 0x28(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x407ae0
jmp 0x407794
leaq 0x40(%rsp), %rdi
callq 0x47ebf0
movq 0x98(%rsp), %rdi
callq 0x480630
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
callq 0x47ee20
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x480630
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x47ee20
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rcx
movq 0x88(%rsp), %r9
movq 0x80(%rsp), %r8
movq %rsp, %rax
movq %r8, (%rax)
movl $0x64, %r8d
callq 0x407870
jmp 0x407815
leaq 0x60(%rsp), %rdi
callq 0x47ebf0
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x47ebf0
jmp 0x407859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x47ebf0
movq 0x38(%rsp), %rdi
callq 0x4b0e70
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APKeyDerivation.cpp
// Function: APDigest::pbkdf2(void const*, unsigned long, void const*, unsigned long, unsigned int, unsigned char*, unsigned long)
void APDigest::pbkdf2(
    const void *password, size_t passwordLen,
    const void *salt,     size_t saltLen,
    uint32_t iterations,
    uint8_t* dk,          size_t dkLen)
{
    uint8_t *saltBlock = new uint8_t[saltLen + 4];
    uint32_t blockNumber = 1;
    memcpy (saltBlock, salt, saltLen);
    while (dkLen >= DIGEST_SIZE)
    {
        PRF((const uint8_t*)password, passwordLen, 
            saltBlock, saltLen,
            iterations, blockNumber++, dk, DIGEST_SIZE);
        dk += DIGEST_SIZE;
        dkLen -= DIGEST_SIZE;
    }

    if (dkLen > 0)
    {
        PRF((const uint8_t*)password, passwordLen, 
            saltBlock, saltLen,
            iterations, blockNumber, dk, dkLen);
    }
    delete [] saltBlock;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq %r9, 0x28(%rsp)
movq 0x38(%rsp), %rdi
addq $0x4, %rdi
callq 0x412c50
movq %rax, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x401108
cmpq $0x40, 0x60(%rsp)
jb 0x40792b
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movl %r9d, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq $0x40, 0x8(%rsp)
callq 0x407990
movq 0x28(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
subq $0x40, %rax
movq %rax, 0x60(%rsp)
jmp 0x4078c6
cmpq $0x0, 0x60(%rsp)
jbe 0x407969
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movq 0x28(%rsp), %r10
movq 0x60(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x407990
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x407983
movq 0x10(%rsp), %rdi
callq 0x411d70
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APKeyDerivation.cpp
// Function: PRF(unsigned char const*, unsigned long, unsigned char*, unsigned long, unsigned int, unsigned int, unsigned char*, unsigned long)
static void PRF(
   const uint8_t *password, size_t passwordLen,
   uint8_t *saltBlock, size_t saltLen,
   uint32_t iterations,
   uint32_t blockNumber,
   uint8_t *dk, size_t dkLen)   // dkLen <= APDigest::DIGEST_SIZE
{
    uint8_t mac[APDigest::DIGEST_SIZE];
    /* saltBlock = [ Salt || INT (blockNumber)]. */
    saltBlock[saltLen + 0] = (uint8_t)(blockNumber >> 24);
    saltBlock[saltLen + 1] = (uint8_t)(blockNumber >> 16);
    saltBlock[saltLen + 2] = (uint8_t)(blockNumber >> 8);
    saltBlock[saltLen + 3] = (uint8_t)(blockNumber);

    APDigest::hmac (
        password, passwordLen, 
        saltBlock, saltLen + 4, 
        mac, sizeof(mac));
    memcpy (dk, mac, dkLen);

    while (--iterations > 0)
    {
        APDigest::hmac (
            password, passwordLen, 
            mac, APDigest::DIGEST_SIZE, 
            mac, APDigest::DIGEST_SIZE);
        for (uint32_t i = 0; i < dkLen; i++) dk[i] ^= mac[i];
    }
}

// Assembly:
subq $0x78, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movl %r9d, 0x50(%rsp)
movl 0x50(%rsp), %eax
shrl $0x18, %eax
movb %al, %dl
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x50(%rsp), %eax
shrl $0x10, %eax
movb %al, %dl
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movb %dl, 0x1(%rax,%rcx)
movl 0x50(%rsp), %eax
shrl $0x8, %eax
movb %al, %dl
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movb %dl, 0x2(%rax,%rcx)
movl 0x50(%rsp), %eax
movb %al, %dl
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movb %dl, 0x3(%rax,%rcx)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
addq $0x4, %rcx
leaq 0x10(%rsp), %r8
movl $0x40, %r9d
callq 0x407460
movq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x401108
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
cmpl $0x0, %eax
jbe 0x407ad1
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x10(%rsp), %r8
movl $0x40, %r9d
movq %r9, %rcx
callq 0x407460
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpq 0x88(%rsp), %rax
jae 0x407acf
movl 0xc(%rsp), %eax
movzbl 0x10(%rsp,%rax), %esi
movq 0x80(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x407a96
jmp 0x407a5c
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APUser.cpp
// Function: APUser::createToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const std::string APUser::createToken(
    const std::string& tag, 
    const std::string& payload)
{
    std::ostringstream s;
    s << tag << AP_SEP << std::hex << uint64_t(time(0)) << AP_SEP << payload << AP_SEP;

    std::string p = s.str();
    return p + m_private_key.signMessage(p);
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq %rcx, 0x218(%rsp)
movq 0x228(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x476f10
movq 0x40(%rsp), %rdi
movq 0x220(%rsp), %rsi
callq 0x481620
movq %rax, 0x48(%rsp)
jmp 0x407c7c
movq 0x48(%rsp), %rdi
movl $0x2e, %esi
callq 0x46ec20
movq %rax, 0x20(%rsp)
jmp 0x407c92
movq 0x20(%rsp), %rdi
leaq 0x8e2(%rip), %rsi       # 0x408580
callq 0x46d810
movq %rax, 0x18(%rsp)
jmp 0x407caa
xorl %eax, %eax
movl %eax, %edi
callq 0x534b20
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x46f300
movq %rax, 0x10(%rsp)
jmp 0x407cc7
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x46ec20
movq %rax, 0x8(%rsp)
jmp 0x407cdd
movq 0x8(%rsp), %rdi
movq 0x218(%rsp), %rsi
callq 0x481620
movq %rax, (%rsp)
jmp 0x407cf5
movq (%rsp), %rdi
movl $0x2e, %esi
callq 0x46ec20
jmp 0x407d05
leaq 0x70(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x477c00
jmp 0x407d19
movq 0x38(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x4087f0
jmp 0x407d2f
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x4085a0
jmp 0x407d45
leaq 0x50(%rsp), %rdi
callq 0x47ebf0
leaq 0x70(%rsp), %rdi
callq 0x47ebf0
leaq 0xa0(%rsp), %rdi
callq 0x473810
movq 0x30(%rsp), %rax
addq $0x238, %rsp            # imm = 0x238
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x407dc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x407dbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x47ebf0
leaq 0x70(%rsp), %rdi
callq 0x47ebf0
leaq 0xa0(%rsp), %rdi
callq 0x473810
movq 0x98(%rsp), %rdi
callq 0x4b0e70
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APUser.cpp
// Function: APUser::registerNewUser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const std::string APUser::registerNewUser(
    const std::string& pw_reset_info)
{
    std::ostringstream payload;
    payload << AP_DEFAULT_ALGO << AP_SEP << getPublicKey();
    if (!pw_reset_info.empty())
        payload << AP_SEP << B64Encode(
            pw_reset_info.c_str(), pw_reset_info.length());
    return createToken(AP_TAG_NEW_USER, payload.str());
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq 0x268(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x476f10
movq 0x40(%rsp), %rdi
leaq 0x1798dc(%rip), %rsi    # 0x581753
callq 0x46ecf0
movq %rax, 0x48(%rsp)
jmp 0x407e83
movq 0x48(%rsp), %rdi
movl $0x2e, %esi
callq 0x46ec20
movq %rax, 0x20(%rsp)
jmp 0x407e99
movq 0x38(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x407df0
jmp 0x407ead
movq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x481620
jmp 0x407ec1
leaq 0xb8(%rsp), %rdi
callq 0x47ebf0
movq 0x260(%rsp), %rdi
callq 0x47f110
testb $0x1, %al
jne 0x407fba
leaq 0xe8(%rsp), %rdi
movl $0x2e, %esi
callq 0x46ec20
movq %rax, 0x18(%rsp)
jmp 0x407efc
movq 0x260(%rsp), %rdi
callq 0x480630
movq %rax, 0x10(%rsp)
movq 0x260(%rsp), %rdi
callq 0x47ee20
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x98(%rsp), %rdi
callq 0x40f930
jmp 0x407f32
movq 0x18(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x481620
jmp 0x407f46
leaq 0x98(%rsp), %rdi
callq 0x47ebf0
jmp 0x407fba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0x4080a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x47ebf0
jmp 0x4080a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x47ebf0
jmp 0x4080a6
leaq 0x77(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x412d90
movq 0x8(%rsp), %rdx
leaq 0x1a0af2(%rip), %rsi    # 0x5a8ac7
leaq 0x78(%rsp), %rdi
callq 0x405970
jmp 0x407fe1
leaq 0x50(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x477c00
jmp 0x407ff5
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x407c10
jmp 0x408010
leaq 0x50(%rsp), %rdi
callq 0x47ebf0
leaq 0x78(%rsp), %rdi
callq 0x47ebf0
leaq 0x77(%rsp), %rdi
callq 0x412db0
leaq 0xe8(%rsp), %rdi
callq 0x473810
movq 0x30(%rsp), %rax
addq $0x278, %rsp            # imm = 0x278
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0x40809c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0x408092
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x47ebf0
leaq 0x78(%rsp), %rdi
callq 0x47ebf0
leaq 0x77(%rsp), %rdi
callq 0x412db0
leaq 0xe8(%rsp), %rdi
callq 0x473810
movq 0xe0(%rsp), %rdi
callq 0x4b0e70
// File: msotoodeh[P]asymmetric-passwords/client/APUser.cpp
// Function: APUser::changePassword[abi:cxx11](APUser const&)
const std::string APUser::changePassword(
    const APUser& new_key)
{
    std::string payload = new_key.getPublicKey();
    std::string token = createToken(AP_TAG_CHANGE_PASSWORD, payload);
    m_private_key = new_key.m_private_key;
    return token;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x407df0
movb $0x0, 0x5f(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x412d90
movq 0x18(%rsp), %rdx
leaq 0x179452(%rip), %rsi    # 0x58175c
leaq 0x38(%rsp), %rdi
callq 0x405970
jmp 0x408316
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
leaq 0x38(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x407c10
jmp 0x408330
leaq 0x38(%rsp), %rdi
callq 0x47ebf0
leaq 0x37(%rsp), %rdi
callq 0x412db0
movq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x408890
jmp 0x408358
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x4083bc
jmp 0x4083b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x40838e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x47ebf0
leaq 0x37(%rsp), %rdi
callq 0x412db0
jmp 0x4083d3
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x47ebf0
jmp 0x4083d3
movq (%rsp), %rdi
callq 0x47ebf0
leaq 0x60(%rsp), %rdi
callq 0x47ebf0
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x47ebf0
movq 0x28(%rsp), %rdi
callq 0x4b0e70
nopw (%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/client/APPrivateKey.cpp
// Function: APPrivateKey::signMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string APPrivateKey::signMessage(const std::string& msg)
{
    unsigned char sig[SignatureSize];
    ed25519_SignMessage (sig, m_Key, &edp_signature_blinding,
        (const unsigned char*)msg.c_str(), msg.length());

    return B64Encode(sig, sizeof(sig));
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x480630
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0x47ee20
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq %rax, %r8
leaq 0x1ea99c(%rip), %rdx    # 0x5f31f8
callq 0x40abb0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x40, %edx
callq 0x40f930
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: APVerifier::setKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int APVerifier::setKey(const std::string& keyStr)
{
    unsigned char key[APPublicKey::PublicKeySize];
    do
    {
        if (B64Decode(keyStr, key, sizeof(key)) != sizeof(key))
        {
            m_error = AP_E_B64_ITEM;
            break;
        }

        m_public_key.setKey(key);
        m_error = AP_SUCCESS;

    } while(0);
    return m_error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
callq 0x40fab0
cmpq $0x20, %rax
je 0x4089c0
movq 0x8(%rsp), %rax
movl $0xfffffff6, 0x20(%rax) # imm = 0xFFFFFFF6
jmp 0x4089db
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40a050
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: hex_string_to_u64(char const*, unsigned long&)
const char* hex_string_to_u64(const char* p, uint64_t& val)
{
    val = 0;
    do
    {
        int d = get_hex_digit(*p);
        if (d < 0) break;

        p++;
        val = (val << 4) + d;
    } while(1);
    return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x408ab0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x408a74
jmp 0x408aa6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
shlq $0x4, %rcx
movslq 0x4(%rsp), %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x408a5a
jmp 0x408aa6
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: get_hex_digit(char)
static int get_hex_digit(char c)
{
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    return -1;
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
cmpl $0x30, %eax
jl 0x408ad9
movsbl -0x5(%rsp), %eax
cmpl $0x39, %eax
jg 0x408ad9
movsbl -0x5(%rsp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rsp)
jmp 0x408b2b
movsbl -0x5(%rsp), %eax
cmpl $0x41, %eax
jl 0x408afe
movsbl -0x5(%rsp), %eax
cmpl $0x46, %eax
jg 0x408afe
movsbl -0x5(%rsp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rsp)
jmp 0x408b2b
movsbl -0x5(%rsp), %eax
cmpl $0x61, %eax
jl 0x408b23
movsbl -0x5(%rsp), %eax
cmpl $0x66, %eax
jg 0x408b23
movsbl -0x5(%rsp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rsp)
jmp 0x408b2b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: APVerifier::ValidateToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
int APVerifier::ValidateToken(
    const std::string& token,
    size_t key_index)
{
    unsigned char sig[64];

    do
    {
        m_error = SplitToken(token);
        if (m_error != AP_SUCCESS) break;

        size_t nItems = m_items.size();

        // Last item is the signature in base64 format
        std::string& signature = m_items[nItems-1];
        if (B64Decode(signature, sig, sizeof(sig)) != sizeof(sig))
        {
            m_error = AP_E_B64_ITEM;
            break;
        }

        // If self-sined, key_index points to the public key
        if (key_index > 0)
        {
            if (key_index < 2 || key_index >= (nItems - 1))
            {
                m_error = AP_E_PARAMETER;
                break;
            }
            if (setKey(m_items[key_index]) != AP_SUCCESS) break;
        }

        m_error = m_public_key.verifySignature(
            (const unsigned char*)token.c_str(), 
            token.length() - signature.length(), 
            &sig[0]) ? 
            AP_SUCCESS : AP_E_SIGNATURE;

    } while(0);
    return m_error;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x408b30
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
je 0x408dfa
jmp 0x408f0e
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x409310
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x38, %rdi
movq 0x28(%rsp), %rsi
subq $0x1, %rsi
callq 0x409330
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x40, %edx
callq 0x40fab0
cmpq $0x40, %rax
je 0x408e54
movq 0x18(%rsp), %rax
movl $0xfffffff6, 0x20(%rax) # imm = 0xFFFFFFF6
jmp 0x408f0e
cmpq $0x0, 0x70(%rsp)
jbe 0x408eb1
cmpq $0x2, 0x70(%rsp)
jb 0x408e77
movq 0x70(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x408e88
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
jmp 0x408f0e
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movq 0x70(%rsp), %rsi
callq 0x409330
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x408980
cmpl $0x0, %eax
je 0x408eaf
jmp 0x408f0e
jmp 0x408eb1
movq 0x78(%rsp), %rdi
callq 0x480630
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0x47ee20
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x47ee20
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
subq %rax, %rdx
leaq 0x30(%rsp), %rcx
callq 0x40a0d0
movb %al, %sil
movq 0x18(%rsp), %rax
movl $0xfffffff8, %ecx       # imm = 0xFFFFFFF8
xorl %edx, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %eax
addq $0x88, %rsp
retq
nop
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: APVerifier::parseUserRegistrationToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool APVerifier::parseUserRegistrationToken(
    const std::string& token)
{
    m_error = SplitToken(token);
    if (m_error == AP_SUCCESS)
    {
        if (m_items.size() < 4)
            m_error = AP_E_FORMAT;
        else if (m_tag != AP_NEW_USER)
            m_error = AP_E_TOKEN;
        else if (m_items[2] != AP_DEFAULT_ALGO)
            m_error = AP_E_ALGO;
        else
            setKey(m_items[3]);
    }
    m_token_expiration_time = 0;
    return isValid();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x408b30
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
jne 0x4090b6
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x409310
cmpq $0x4, %rax
jae 0x409044
movq (%rsp), %rax
movl $0xfffffffe, 0x20(%rax) # imm = 0xFFFFFFFE
jmp 0x4090b4
movq (%rsp), %rax
cmpl $0x6e75, 0x24(%rax)     # imm = 0x6E75
je 0x40905e
movq (%rsp), %rax
movl $0xfffffffc, 0x20(%rax) # imm = 0xFFFFFFFC
jmp 0x4090b2
movq (%rsp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
callq 0x409330
movq %rax, %rdi
leaq 0x1786d9(%rip), %rsi    # 0x581753
callq 0x409390
testb $0x1, %al
jne 0x409085
jmp 0x409092
movq (%rsp), %rax
movl $0xfffffffd, 0x20(%rax) # imm = 0xFFFFFFFD
jmp 0x4090b0
movq (%rsp), %rdi
addq $0x38, %rdi
movl $0x3, %esi
callq 0x409330
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x408980
jmp 0x4090b2
jmp 0x4090b4
jmp 0x4090b6
movq (%rsp), %rdi
movq $0x0, 0x30(%rdi)
callq 0x409370
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: APVerifier::parseUserLoginToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool APVerifier::parseUserLoginToken(const std::string& token)
{
    do
    {
        if (ValidateToken(token) != AP_SUCCESS) break;

        if (m_tag != AP_USER_LOGIN)
        {
            m_error = AP_E_TOKEN;
            break;
        }

        // item(2) is token duration (in hex)
        uint64_t duration = 0;
        const char* p = hex_string_to_u64(m_items[2].c_str(), duration);
        if (*p != '\0' || duration > APV_MAX_LOGIN_DURATION)
        {
            m_error = AP_E_TIMESTAMP;
            break;
        }

        m_token_expiration_time = (uint64_t)time(NULL) + duration;

    } while(0);
    return isValid();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x408db0
cmpl $0x0, %eax
je 0x409103
jmp 0x409190
movq (%rsp), %rax
cmpl $0x6c69, 0x24(%rax)     # imm = 0x6C69
je 0x40911d
movq (%rsp), %rax
movl $0xfffffffc, 0x20(%rax) # imm = 0xFFFFFFFC
jmp 0x409190
movq (%rsp), %rdi
movq $0x0, 0x10(%rsp)
addq $0x38, %rdi
movl $0x2, %esi
callq 0x409330
movq %rax, %rdi
callq 0x480630
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x408a40
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x40916a
cmpq $0xe10, 0x10(%rsp)      # imm = 0xE10
jbe 0x409177
movq (%rsp), %rax
movl $0xfffffffb, 0x20(%rax) # imm = 0xFFFFFFFB
jmp 0x409190
xorl %eax, %eax
movl %eax, %edi
callq 0x534b20
movq %rax, %rcx
movq (%rsp), %rax
addq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq (%rsp), %rdi
callq 0x409370
andb $0x1, %al
addq $0x28, %rsp
retq
// File: msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: APVerifier::parseChangePasswordToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool APVerifier::parseChangePasswordToken(const std::string& token)
{
    if (ValidateToken(token) == AP_SUCCESS)
    {
        if (m_tag == AP_CHANGE_PASSWORD)
            setKey(getItem(2)); // Change public key
        else
            m_error = AP_E_TOKEN;
    }
    return isValid();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x408db0
cmpl $0x0, %eax
jne 0x409200
movq (%rsp), %rax
cmpl $0x6370, 0x24(%rax)     # imm = 0x6370
jne 0x4091f3
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x408f20
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x408980
jmp 0x4091fe
movq (%rsp), %rax
movl $0xfffffffc, 0x20(%rax) # imm = 0xFFFFFFFC
jmp 0x409200
movq (%rsp), %rdi
callq 0x409370
andb $0x1, %al
addq $0x18, %rsp
retq
// File: msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_AddBasePoint
void edp_AddBasePoint(Ext_POINT *p)
{
    U_WORD a[K_WORDS], b[K_WORDS], c[K_WORDS], d[K_WORDS], e[K_WORDS];

    ecp_SubReduce(a, p->y, p->x);           /* A = (Y1-X1)*(Y2-X2) */
    ecp_MulReduce(a, a, _w_base_folding8[1].YmX);
    ecp_AddReduce(b, p->y, p->x);           /* B = (Y1+X1)*(Y2+X2) */
    ecp_MulReduce(b, b, _w_base_folding8[1].YpX);
    ecp_MulReduce(c, p->t, _w_base_folding8[1].T2d); /* C = T1*2d*T2 */
    ecp_AddReduce(d, p->z, p->z);           /* D = 2*Z1 */
    ecp_SubReduce(e, b, a);                 /* E = B-A */
    ecp_AddReduce(b, b, a);                 /* H = B+A */
    ecp_SubReduce(a, d, c);                 /* F = D-C */
    ecp_AddReduce(d, d, c);                 /* G = D+C */

    ecp_MulReduce(p->x, e, a);              /* E*F */
    ecp_MulReduce(p->y, b, d);              /* H*G */
    ecp_MulReduce(p->t, e, b);              /* E*H */
    ecp_MulReduce(p->z, d, a);              /* G*F */
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
leaq 0x80(%rsp), %rdi
movq 0xa0(%rsp), %rsi
addq $0x20, %rsi
movq 0xa0(%rsp), %rdx
callq 0x410240
leaq 0x80(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x177669(%rip), %rdx    # 0x5817c0
addq $0x60, %rdx
addq $0x20, %rdx
callq 0x410910
leaq 0x60(%rsp), %rdi
movq 0xa0(%rsp), %rsi
addq $0x20, %rsi
movq 0xa0(%rsp), %rdx
callq 0x410000
leaq 0x60(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x17762d(%rip), %rdx    # 0x5817c0
addq $0x60, %rdx
callq 0x410910
leaq 0x40(%rsp), %rdi
movq 0xa0(%rsp), %rsi
addq $0x60, %rsi
leaq 0x17760c(%rip), %rdx    # 0x5817c0
addq $0x60, %rdx
addq $0x40, %rdx
callq 0x410910
leaq 0x20(%rsp), %rdi
movq 0xa0(%rsp), %rsi
addq $0x40, %rsi
movq 0xa0(%rsp), %rdx
addq $0x40, %rdx
callq 0x410000
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x410240
leaq 0x60(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x410000
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x410240
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x410000
movq 0xa0(%rsp), %rdi
movq %rsp, %rsi
leaq 0x80(%rsp), %rdx
callq 0x410910
movq 0xa0(%rsp), %rdi
addq $0x20, %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x410910
movq 0xa0(%rsp), %rdi
addq $0x60, %rdi
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
callq 0x410910
movq 0xa0(%rsp), %rdi
addq $0x40, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x410910
addq $0xa8, %rsp
retq
nopl (%rax)