name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
cmd_ln_log_help_r | void
cmd_ln_log_help_r(ps_config_t *cmdln, ps_arg_t const* defn)
{
if (defn == NULL)
return;
E_INFO("Arguments list definition:\n");
if (cmdln == NULL) {
cmdln = cmd_ln_parse_r(NULL, defn, 0, NULL, FALSE);
arg_log_r(cmdln, defn, TRUE, FALSE);
ps_config_free(cmdln);
}
else
arg_log_r(cmdln, defn, TRUE, FALSE);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x219e9
jmp 0x21a5c
movl $0x1, %edi
leaq 0x5819f(%rip), %rsi # 0x79b94
movl $0x22a, %edx # imm = 0x22A
leaq 0x58365(%rip), %rcx # 0x79d66
movb $0x0, %al
callq 0x23450
cmpq $0x0, -0x8(%rbp)
jne 0x21a48
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdi
movl %r8d, %edx
callq 0x20f60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x21a70
movq -0x8(%rbp), %rdi
callq 0x13430
jmp 0x21a5c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x21a70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/cmd_ln.c |
hash_table_display | void
hash_table_display(hash_table_t * h, int32 showdisplay)
{
hash_entry_t *e;
int i, j;
j = 0;
printf("Hash with chaining representation of the hash table\n");
for (i = 0; i < h->size; i++) {
e = &(h->table[i]);
if (e->key != NULL) {
printf("|key:");
if (showdisplay)
printf("%s", e->key);
else
printf("%p", e->key);
printf("|len:%zd|val=%zd|->", e->len, (size_t)e->val);
if (e->next == NULL) {
printf("NULL\n");
}
j++;
for (e = e->next; e; e = e->next) {
printf("|key:");
if (showdisplay)
printf("%s", e->key);
printf("|len:%zd|val=%zd|->", e->len, (size_t)e->val);
if (e->next == NULL) {
printf("NULL\n");
}
j++;
}
}
}
printf("The total number of keys =%d\n", j);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
leaq 0x5717c(%rip), %rdi # 0x79ef9
movb $0x0, %al
callq 0x7170
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x22edb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x22ecb
leaq 0x57168(%rip), %rdi # 0x79f2e
movb $0x0, %al
callq 0x7170
cmpl $0x0, -0xc(%rbp)
je 0x22dea
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x60162(%rip), %rdi # 0x82f43
movb $0x0, %al
callq 0x7170
jmp 0x22dff
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x5f108(%rip), %rdi # 0x81f00
movb $0x0, %al
callq 0x7170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x5711e(%rip), %rdi # 0x79f34
movb $0x0, %al
callq 0x7170
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x22e36
leaq 0x57119(%rip), %rdi # 0x79f48
movb $0x0, %al
callq 0x7170
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22ec9
leaq 0x570d5(%rip), %rdi # 0x79f2e
movb $0x0, %al
callq 0x7170
cmpl $0x0, -0xc(%rbp)
je 0x22e7b
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x600cf(%rip), %rdi # 0x82f43
movb $0x0, %al
callq 0x7170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x570a2(%rip), %rdi # 0x79f34
movb $0x0, %al
callq 0x7170
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x22eb2
leaq 0x5709d(%rip), %rdi # 0x79f48
movb $0x0, %al
callq 0x7170
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22e4b
jmp 0x22ecb
jmp 0x22ecd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22d8b
movl -0x20(%rbp), %esi
leaq 0x57069(%rip), %rdi # 0x79f4e
movb $0x0, %al
callq 0x7170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/hash_table.c |
hash_table_iter_next | hash_iter_t *
hash_table_iter_next(hash_iter_t *itor)
{
/* If there is an entry, walk down its list. */
if (itor->ent)
itor->ent = itor->ent->next;
/* If we got to the end of the chain, or we had no entry, scan
* forward in the table to find the next non-empty bucket. */
if (itor->ent == NULL) {
while (itor->idx < (size_t)itor->ht->size
&& itor->ht->table[itor->idx].key == NULL)
++itor->idx;
/* If we did not find one then delete the iterator and
* return NULL. */
if (itor->idx == (size_t)itor->ht->size) {
hash_table_iter_free(itor);
return NULL;
}
/* Otherwise use this next entry. */
itor->ent = itor->ht->table + itor->idx;
/* Increase idx for the next time around. */
++itor->idx;
}
return itor;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2305b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x23123
jmp 0x2306c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jae 0x230ac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x230b5
jmp 0x230c7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2306c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jne 0x230f2
movq -0x10(%rbp), %rdi
callq 0x23140
movq $0x0, -0x8(%rbp)
jmp 0x2312b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/hash_table.c |
err_set_loglevel_str | const char *
err_set_loglevel_str(char const *lvl)
{
const char *rv = err_level[min_loglevel];
int i;
if (lvl == NULL)
return NULL;
if (!strncmp(lvl, "ERR_", 4))
lvl += 4;
for (i = 0; i < ERR_MAX; ++i) {
if (!strcmp(lvl, err_level[i])) {
min_loglevel = i;
return rv;
}
}
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x70f7e(%rip), %eax # 0x94320
movl %eax, %ecx
leaq 0x70f85(%rip), %rax # 0x94330
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x233c4
movq $0x0, -0x8(%rbp)
jmp 0x2343c
movq -0x10(%rbp), %rdi
leaq 0x56bcb(%rip), %rsi # 0x79f9a
movl $0x4, %edx
callq 0x7090
cmpl $0x0, %eax
jne 0x233ea
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x23434
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x70f2a(%rip), %rax # 0x94330
movq (%rax,%rcx,8), %rsi
callq 0x7260
cmpl $0x0, %eax
jne 0x23427
movl -0x1c(%rbp), %eax
movl %eax, 0x70f03(%rip) # 0x94320
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2343c
jmp 0x23429
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x233f1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/err.c |
err_msg_system | void
err_msg_system(err_lvl_t lvl, const char *path, long ln, const char *fmt, ...)
{
int local_errno = errno;
char msg[1024];
va_list ap;
if (!err_cb)
return;
if (lvl < min_loglevel)
return;
va_start(ap, fmt);
vsnprintf(msg, sizeof(msg), fmt, ap);
va_end(ap);
if (path) {
const char *fname = path2basename(path);
if (lvl == ERR_INFO)
err_cb(err_user_data, lvl, "%s: %s(%ld): %s: %s\n", err_level[lvl], fname, ln, msg, strerror(local_errno));
else
err_cb(err_user_data, lvl, "%s: \"%s\", line %ld: %s: %s\n", err_level[lvl], fname, ln, msg, strerror(local_errno));
} else {
err_cb(err_user_data, lvl, "%s: %s\n", msg, strerror(local_errno));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x5b0, %rsp # imm = 0x5B0
testb %al, %al
je 0x23647
movaps %xmm0, -0x4e0(%rbp)
movaps %xmm1, -0x4d0(%rbp)
movaps %xmm2, -0x4c0(%rbp)
movaps %xmm3, -0x4b0(%rbp)
movaps %xmm4, -0x4a0(%rbp)
movaps %xmm5, -0x490(%rbp)
movaps %xmm6, -0x480(%rbp)
movaps %xmm7, -0x470(%rbp)
movq %r9, -0x4e8(%rbp)
movq %r8, -0x4f0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x7060
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, 0x70ce2(%rip) # 0x94358
jne 0x2367d
jmp 0x238c8
movl -0x4(%rbp), %eax
cmpl 0x70c9a(%rip), %eax # 0x94320
jae 0x2368d
jmp 0x238c8
leaq -0x450(%rbp), %rax
leaq -0x510(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
leaq -0x430(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x450(%rbp), %rcx
movl $0x400, %esi # imm = 0x400
callq 0x7100
leaq -0x450(%rbp), %rax
cmpq $0x0, -0x10(%rbp)
je 0x23863
movq -0x10(%rbp), %rdi
callq 0x20c60
movq %rax, -0x458(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x237b1
movq 0x70c55(%rip), %rax # 0x94358
movq %rax, -0x518(%rbp)
movq 0x7106f(%rip), %rax # 0x94780
movq %rax, -0x548(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x53c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x70c03(%rip), %rax # 0x94330
movq (%rax,%rcx,8), %rax
movq %rax, -0x538(%rbp)
movq -0x458(%rbp), %rax
movq %rax, -0x530(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x528(%rbp)
leaq -0x430(%rbp), %rax
movq %rax, -0x520(%rbp)
movl -0x24(%rbp), %edi
callq 0x7450
movq -0x548(%rbp), %rdi
movl -0x53c(%rbp), %esi
movq -0x538(%rbp), %rcx
movq -0x530(%rbp), %r8
movq -0x528(%rbp), %r9
movq -0x520(%rbp), %r11
movq -0x518(%rbp), %r10
leaq 0x56828(%rip), %rdx # 0x79fc6
movq %r11, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq *%r10
jmp 0x23861
movq 0x70ba0(%rip), %rax # 0x94358
movq %rax, -0x550(%rbp)
movq 0x70fba(%rip), %rax # 0x94780
movq %rax, -0x580(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x574(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x70b4e(%rip), %rax # 0x94330
movq (%rax,%rcx,8), %rax
movq %rax, -0x570(%rbp)
movq -0x458(%rbp), %rax
movq %rax, -0x568(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x560(%rbp)
leaq -0x430(%rbp), %rax
movq %rax, -0x558(%rbp)
movl -0x24(%rbp), %edi
callq 0x7450
movq -0x580(%rbp), %rdi
movl -0x574(%rbp), %esi
movq -0x570(%rbp), %rcx
movq -0x568(%rbp), %r8
movq -0x560(%rbp), %r9
movq -0x558(%rbp), %r11
movq -0x550(%rbp), %r10
leaq 0x56788(%rip), %rdx # 0x79fdb
movq %r11, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq *%r10
jmp 0x238c8
movq 0x70aee(%rip), %rax # 0x94358
movq %rax, -0x588(%rbp)
movq 0x70f08(%rip), %rax # 0x94780
movq %rax, -0x5a0(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x594(%rbp)
leaq -0x430(%rbp), %rax
movq %rax, -0x590(%rbp)
movl -0x24(%rbp), %edi
callq 0x7450
movq -0x5a0(%rbp), %rdi
movl -0x594(%rbp), %esi
movq -0x590(%rbp), %rcx
movq -0x588(%rbp), %r9
movq %rax, %r8
leaq 0x56710(%rip), %rdx # 0x79fd3
movb $0x0, %al
callq *%r9
addq $0x5b0, %rsp # imm = 0x5B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/err.c |
_ckd_malloc__ | void *
__ckd_malloc__(size_t size, const char *caller_file, int caller_line)
{
void *mem;
#if defined(__ADSPBLACKFIN__) && !defined(__linux__)
if ((mem = heap_malloc(heap_lookup(0),size)) == NULL)
if ((mem = heap_malloc(heap_lookup(1),size)) == NULL)
#else
if ((mem = malloc(size)) == NULL)
#endif
ckd_fail("malloc(%d) failed from %s(%d)\n", size,
caller_file, caller_line);
return mem;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x72e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x23caf
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x56388(%rip), %rdi # 0x7a030
movb $0x0, %al
callq 0x23b40
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
_ckd_calloc_2d__ | void *
__ckd_calloc_2d__(size_t d1, size_t d2, size_t elemsize,
const char *caller_file, int caller_line)
{
char **ref, *mem;
size_t i, offset;
mem =
(char *) __ckd_calloc__(d1 * d2, elemsize, caller_file,
caller_line);
ref =
(char **) __ckd_malloc__(d1 * sizeof(void *), caller_file,
caller_line);
for (i = 0, offset = 0; i < d1; i++, offset += d2 * elemsize)
ref[i] = mem + offset;
return ref;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x23c10
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x23c70
movq %rax, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x23e2e
movq -0x38(%rbp), %rdx
addq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x23df1
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
ckd_free | void
ckd_free(void *ptr)
{
#if defined(__ADSPBLACKFIN__) && !defined(__linux__)
if (ptr)
heap_free(0,ptr);
#else
free(ptr);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
_ckd_calloc_4d__ | void ****
__ckd_calloc_4d__(size_t d1,
size_t d2,
size_t d3,
size_t d4,
size_t elem_size,
char *file,
int line)
{
void *store;
void **tmp1;
void ***tmp2;
void ****out;
size_t i, j;
store = calloc(d1 * d2 * d3 * d4, elem_size);
if (store == NULL) {
E_FATAL("ckd_calloc_4d failed for caller at %s(%d) at %s(%d)\n",
file, line, __FILE__, __LINE__);
}
tmp1 = calloc(d1 * d2 * d3, sizeof(void *));
if (tmp1 == NULL) {
E_FATAL("ckd_calloc_4d failed for caller at %s(%d) at %s(%d)\n",
file, line, __FILE__, __LINE__);
}
tmp2 = ckd_calloc(d1 * d2, sizeof(void **));
if (tmp2 == NULL) {
E_FATAL("ckd_calloc_4d failed for caller at %s(%d) at %s(%d)\n",
file, line, __FILE__, __LINE__);
}
out = ckd_calloc(d1, sizeof(void ***));
if (out == NULL) {
E_FATAL("ckd_calloc_4d failed for caller at %s(%d) at %s(%d)\n",
file, line, __FILE__, __LINE__);
}
for (i = 0, j = 0; i < d1*d2*d3; i++, j += d4) {
tmp1[i] = &((char *)store)[j*elem_size];
}
for (i = 0, j = 0; i < d1*d2; i++, j += d3) {
tmp2[i] = &tmp1[j];
}
for (i = 0, j = 0; i < d1; i++, j += d2) {
out[i] = &tmp2[j];
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
imulq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7250
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x240dc
jmp 0x2409c
movq -0x30(%rbp), %r8
movl 0x10(%rbp), %r9d
movl $0x4, %edi
leaq 0x55f9f(%rip), %rax # 0x7a04f
movl $0x148, %edx # imm = 0x148
leaq 0x55ff3(%rip), %rcx # 0x7a0af
movq %rax, %rsi
movq %rax, (%rsp)
movl $0x148, 0x8(%rsp) # imm = 0x148
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
callq 0x7410
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x7250
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x24141
jmp 0x24101
movq -0x30(%rbp), %r8
movl 0x10(%rbp), %r9d
movl $0x4, %edi
leaq 0x55f3a(%rip), %rax # 0x7a04f
movl $0x14e, %edx # imm = 0x14E
leaq 0x55f8e(%rip), %rcx # 0x7a0af
movq %rax, %rsi
movq %rax, (%rsp)
movl $0x14e, 0x8(%rsp) # imm = 0x14E
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
callq 0x7410
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
movl $0x8, %esi
leaq 0x55ef9(%rip), %rdx # 0x7a04f
movl $0x151, %ecx # imm = 0x151
callq 0x23c10
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x241ad
jmp 0x2416d
movq -0x30(%rbp), %r8
movl 0x10(%rbp), %r9d
movl $0x4, %edi
leaq 0x55ece(%rip), %rax # 0x7a04f
movl $0x154, %edx # imm = 0x154
leaq 0x55f22(%rip), %rcx # 0x7a0af
movq %rax, %rsi
movq %rax, (%rsp)
movl $0x154, 0x8(%rsp) # imm = 0x154
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
callq 0x7410
movq -0x8(%rbp), %rdi
movl $0x8, %esi
leaq 0x55e92(%rip), %rdx # 0x7a04f
movl $0x157, %ecx # imm = 0x157
callq 0x23c10
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x24214
jmp 0x241d4
movq -0x30(%rbp), %r8
movl 0x10(%rbp), %r9d
movl $0x4, %edi
leaq 0x55e67(%rip), %rax # 0x7a04f
movl $0x15a, %edx # imm = 0x15A
leaq 0x55ebb(%rip), %rcx # 0x7a0af
movq %rax, %rsi
movq %rax, (%rsp)
movl $0x15a, 0x8(%rsp) # imm = 0x15A
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
callq 0x7410
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x24271
movq -0x38(%rbp), %rdx
movq -0x60(%rbp), %rax
imulq -0x28(%rbp), %rax
addq %rax, %rdx
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x24224
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x242c8
movq -0x40(%rbp), %rdx
movq -0x60(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x24281
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x24317
movq -0x48(%rbp), %rdx
movq -0x60(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x242d8
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/ckd_alloc.c |
glist_insert_int32 | gnode_t *
glist_insert_int32(gnode_t * gn, int32 val)
{
gnode_t *newgn;
newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
newgn->data.i = val;
newgn->next = gn->next;
gn->next = newgn;
return newgn;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x10, %esi
leaq 0x5444b(%rip), %rdx # 0x7a5eb
movl $0xcd, %ecx
callq 0x23c10
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/util/glist.c |
glist_insert_float32 | gnode_t *
glist_insert_float32(gnode_t * gn, float32 val)
{
gnode_t *newgn;
newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
newgn->data.fl = (double)val;
newgn->next = gn->next;
gn->next = newgn;
return newgn;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl $0x1, %edi
movl $0x10, %esi
leaq 0x54389(%rip), %rdx # 0x7a5eb
movl $0xea, %ecx
callq 0x23c10
movq %rax, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/glist.c |
gnode_free | gnode_t *
gnode_free(gnode_t * gn, gnode_t * pred)
{
gnode_t *next;
next = gn->next;
if (pred) {
assert(pred->next == gn);
pred->next = next;
}
ckd_free((char *) gn);
return next;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2637e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x26353
jmp 0x26372
leaq 0x542ed(%rip), %rdi # 0x7a647
leaq 0x5428a(%rip), %rsi # 0x7a5eb
movl $0x107, %edx # imm = 0x107
leaq 0x542eb(%rip), %rcx # 0x7a658
callq 0x71c0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x23e40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/glist.c |
listelem_add_block | static void
listelem_add_block(listelem_alloc_t *list, char *caller_file, int caller_line)
{
char **cpp, *cp;
size_t j;
int32 blocksize;
blocksize = list->blocksize ? gnode_int32(list->blocksize) : MIN_ALLOC;
/* Check if block size should be increased (if many requests for this size) */
if (list->blk_alloc == 0) {
/* See above. No sense in allocating blocks bigger than
* 256KiB (well, actually, there might be, but we'll worry
* about that later). */
blocksize <<= 1;
if (blocksize * list->elemsize > (1 << 18))
blocksize = (1 << 18) / list->elemsize;
list->blk_alloc = (1 << 18) / (blocksize * list->elemsize);
}
/* Allocate block */
cpp = list->freelist =
(char **) __ckd_calloc__(blocksize, list->elemsize,
caller_file, caller_line);
list->blocks = glist_add_ptr(list->blocks, cpp);
list->blocksize = glist_add_int32(list->blocksize, blocksize);
cp = (char *) cpp;
/* Link up the blocks via their first machine word. */
for (j = blocksize - 1; j > 0; --j) {
cp += list->elemsize;
*cpp = cp;
cpp = (char **) cp;
}
/* Make sure the last element's forward pointer is NULL */
*cpp = NULL;
--list->blk_alloc;
++list->n_blocks;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2650f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2651a
movl $0x32, %eax
movq %rax, -0x40(%rbp)
jmp 0x2651a
movq -0x40(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2657d
movl -0x34(%rbp), %eax
shll %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x18(%rcx), %rax
cmpq $0x40000, %rax # imm = 0x40000
jbe 0x2655b
movq -0x8(%rbp), %rcx
movl $0x40000, %eax # imm = 0x40000
xorl %edx, %edx
divq 0x18(%rcx)
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
movq -0x8(%rbp), %rax
imulq 0x18(%rax), %rcx
movl $0x40000, %eax # imm = 0x40000
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movslq -0x34(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x23c10
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x25e50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x34(%rbp), %esi
callq 0x25ea0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x26623
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x265eb
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/listelem_alloc.c |
listelem_stats | void
listelem_stats(listelem_alloc_t *list)
{
gnode_t *gn, *gn2;
char **cpp;
size_t n;
E_INFO("Linklist stats:\n");
for (n = 0, cpp = list->freelist; cpp;
cpp = (char **) (*cpp), n++);
E_INFO
("elemsize %lu, #alloc %lu, #freed %lu, #freelist %lu\n",
(unsigned long)list->elemsize,
(unsigned long)list->n_alloc,
(unsigned long)list->n_freed,
(unsigned long)n);
E_INFO("Allocated blocks:\n");
gn2 = list->blocksize;
for (gn = list->blocks; gn; gn = gnode_next(gn)) {
E_INFO("%p (%d * %d bytes)\n", gnode_ptr(gn), gnode_int32(gn2), list->elemsize);
gn2 = gnode_next(gn2);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
leaq 0x53c7a(%rip), %rsi # 0x7a682
movl $0x119, %edx # imm = 0x119
leaq 0x53da1(%rip), %rcx # 0x7a7b5
movb $0x0, %al
callq 0x23450
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26a50
jmp 0x26a37
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26a2e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %r10
movq -0x28(%rbp), %rax
movl $0x1, %edi
leaq 0x53c0a(%rip), %rsi # 0x7a682
movl $0x121, %edx # imm = 0x121
leaq 0x53d42(%rip), %rcx # 0x7a7c6
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
leaq 0x53be2(%rip), %rsi # 0x7a682
movl $0x122, %edx # imm = 0x122
leaq 0x53d4f(%rip), %rcx # 0x7a7fb
movb $0x0, %al
callq 0x23450
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x26b25
movq -0x10(%rbp), %rax
movq (%rax), %r8
movq -0x18(%rbp), %rax
movq (%rax), %r9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x1, %edi
leaq 0x53b8e(%rip), %rsi # 0x7a682
movl $0x125, %edx # imm = 0x125
leaq 0x53d0e(%rip), %rcx # 0x7a80e
movq %rax, (%rsp)
movb $0x0, %al
callq 0x23450
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x26acb
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/listelem_alloc.c |
fclose_comp | void
fclose_comp(FILE * fp, int32 ispipe)
{
if (ispipe) {
#ifdef HAVE_POPEN
#if defined(_WIN32) && (!defined(__SYMBIAN32__))
_pclose(fp);
#else
pclose(fp);
#endif
#endif
}
else
fclose(fp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x26fa0
movq -0x8(%rbp), %rdi
callq 0x7180
jmp 0x26fa9
movq -0x8(%rbp), %rdi
callq 0x7120
addq $0x10, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/util/pio.c |
fopen_compchk | FILE *
fopen_compchk(const char *file, int32 * ispipe)
{
#ifndef HAVE_POPEN
*ispipe = 0; /* No popen() on WinCE */
/* And therefore the rest of this function is useless. */
return (fopen_comp(file, "r", ispipe));
#else /* HAVE_POPEN */
int32 isgz;
FILE *fh;
/* First just try to fopen_comp() it */
if ((fh = fopen_comp(file, "r", ispipe)) != NULL)
return fh;
else {
char *tmpfile;
size_t k;
/* File doesn't exist; try other compressed/uncompressed form, as appropriate */
guess_comptype(file, ispipe, &isgz);
k = strlen(file);
tmpfile = ckd_calloc(k+5, 1);
strcpy(tmpfile, file);
switch (isgz) {
case COMP_GZIP:
tmpfile[k - 3] = '\0';
break;
case COMP_BZIP2:
tmpfile[k - 4] = '\0';
break;
case COMP_COMPRESS:
tmpfile[k - 2] = '\0';
break;
case COMP_NONE:
strcpy(tmpfile + k, ".gz");
if ((fh = fopen_comp(tmpfile, "r", ispipe)) != NULL) {
E_WARN("Using %s instead of %s\n", tmpfile, file);
ckd_free(tmpfile);
return fh;
}
strcpy(tmpfile + k, ".bz2");
if ((fh = fopen_comp(tmpfile, "r", ispipe)) != NULL) {
E_WARN("Using %s instead of %s\n", tmpfile, file);
ckd_free(tmpfile);
return fh;
}
strcpy(tmpfile + k, ".Z");
if ((fh = fopen_comp(tmpfile, "r", ispipe)) != NULL) {
E_WARN("Using %s instead of %s\n", tmpfile, file);
ckd_free(tmpfile);
return fh;
}
ckd_free(tmpfile);
return NULL;
}
E_WARN("Using %s instead of %s\n", tmpfile, file);
fh = fopen_comp(tmpfile, "r", ispipe);
ckd_free(tmpfile);
return NULL;
}
#endif /* HAVE_POPEN */
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b6b3(%rip), %rsi # 0x82682
callq 0x26b30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x26feb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27249
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x26e30
movq -0x10(%rbp), %rdi
callq 0x7130
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x5, %rdi
leaq 0x53835(%rip), %rdx # 0x7a84d
movl $0x1, %esi
movl $0xde, %ecx
callq 0x23c10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x70a0
movl -0x1c(%rbp), %eax
movq %rax, -0x40(%rbp)
subq $0x3, %rax
ja 0x271f9
movq -0x40(%rbp), %rax
leaq 0x537d0(%rip), %rcx # 0x7a824
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x3, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x271f9
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x4, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x271f9
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x2, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x271f9
movq -0x30(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x538bd(%rip), %rsi # 0x7a968
callq 0x70a0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b5c3(%rip), %rsi # 0x82682
callq 0x26b30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2710b
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %r9
movl $0x2, %edi
leaq 0x5376b(%rip), %rsi # 0x7a84d
movl $0xed, %edx
leaq 0x5387e(%rip), %rcx # 0x7a96c
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27249
movq -0x30(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x5386a(%rip), %rsi # 0x7a984
callq 0x70a0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b554(%rip), %rsi # 0x82682
callq 0x26b30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2717a
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %r9
movl $0x2, %edi
leaq 0x536fc(%rip), %rsi # 0x7a84d
movl $0xf3, %edx
leaq 0x5380f(%rip), %rcx # 0x7a96c
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27249
movq -0x30(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x53800(%rip), %rsi # 0x7a989
callq 0x70a0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b4e5(%rip), %rsi # 0x82682
callq 0x26b30
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x271e6
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %r9
movl $0x2, %edi
leaq 0x5368d(%rip), %rsi # 0x7a84d
movl $0xf9, %edx
leaq 0x537a0(%rip), %rcx # 0x7a96c
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27249
movq -0x30(%rbp), %rdi
callq 0x23e40
movq $0x0, -0x8(%rbp)
jmp 0x27249
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %r9
movl $0x2, %edi
leaq 0x53640(%rip), %rsi # 0x7a84d
movl $0x100, %edx # imm = 0x100
leaq 0x53753(%rip), %rcx # 0x7a96c
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b453(%rip), %rsi # 0x82682
callq 0x26b30
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x23e40
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/pio.c |
fread_line | char *
fread_line(FILE *stream, size_t *out_len)
{
char *output, *outptr;
char buf[128];
output = outptr = NULL;
while (fgets(buf, sizeof(buf), stream)) {
size_t len = strlen(buf);
/* Append this data to the buffer. */
if (output == NULL) {
output = (char *)ckd_malloc(len + 1);
outptr = output;
}
else {
size_t cur = outptr - output;
output = (char *)ckd_realloc(output, cur + len + 1);
outptr = output + cur;
}
memcpy(outptr, buf, len + 1);
outptr += len;
/* Stop on a short read or end of line. */
if (len < sizeof(buf)-1 || buf[len-1] == '\n')
break;
}
if (out_len) *out_len = outptr - output;
return output;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x80, %esi
callq 0x7240
cmpq $0x0, %rax
je 0x277c5
leaq -0xa0(%rbp), %rdi
callq 0x7130
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27726
movq -0xa8(%rbp), %rdi
addq $0x1, %rdi
leaq 0x5313f(%rip), %rsi # 0x7a84d
movl $0x184, %edx # imm = 0x184
callq 0x23c70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x27772
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
movq -0xb0(%rbp), %rsi
addq -0xa8(%rbp), %rsi
addq $0x1, %rsi
leaq 0x530f8(%rip), %rdx # 0x7a84d
movl $0x189, %ecx # imm = 0x189
callq 0x23cc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0xb0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
addq $0x1, %rdx
callq 0x72d0
movq -0xa8(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x7f, -0xa8(%rbp)
jb 0x277be
movq -0xa8(%rbp), %rax
subq $0x1, %rax
movsbl -0xa0(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x277c0
jmp 0x277c5
jmp 0x276c3
cmpq $0x0, -0x10(%rbp)
je 0x277de
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/pio.c |
stat_retry | int32
stat_retry(const char *file, struct stat * statbuf)
{
int32 i;
for (i = 0; i < STAT_RETRY_COUNT; i++) {
#ifndef HAVE_SYS_STAT_H
FILE *fp;
if ((fp = (FILE *)fopen(file, "r")) != 0) {
fseek(fp, 0, SEEK_END);
statbuf->st_size = ftell(fp);
fclose(fp);
return 0;
}
#else /* HAVE_SYS_STAT_H */
if (stat(file, statbuf) == 0)
return 0;
#endif
if (i == 0) {
E_ERROR_SYSTEM("Failed to stat file '%s'; retrying...", file);
}
#ifdef HAVE_UNISTD_H
sleep(1);
#endif
}
return -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x27956
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x72b0
cmpl $0x0, %eax
jne 0x27918
movl $0x0, -0x4(%rbp)
jmp 0x2795d
cmpl $0x0, -0x1c(%rbp)
jne 0x27941
movq -0x10(%rbp), %r8
movl $0x3, %edi
leaq 0x52f1f(%rip), %rsi # 0x7a84d
movl $0x1fd, %edx # imm = 0x1FD
leaq 0x53073(%rip), %rcx # 0x7a9ad
movb $0x0, %al
callq 0x23600
movl $0x1, %edi
callq 0x7460
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x278f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/pio.c |
bit_encode_free | int
bit_encode_free(bit_encode_t *be)
{
if (be == NULL)
return 0;
if (--be->refcount > 0)
return be->refcount;
ckd_free(be);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27a3c
movl $0x0, -0x4(%rbp)
jmp 0x27a6f
movq -0x10(%rbp), %rcx
movw 0xa(%rcx), %ax
addw $-0x1, %ax
movw %ax, 0xa(%rcx)
cwtl
cmpl $0x0, %eax
jle 0x27a5f
movq -0x10(%rbp), %rax
movswl 0xa(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x27a6f
movq -0x10(%rbp), %rdi
callq 0x23e40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/pio.c |
acmod_init | acmod_t *
acmod_init(ps_config_t *config, logmath_t *lmath, fe_t *fe, feat_t *fcb)
{
acmod_t *acmod;
acmod = ckd_calloc(1, sizeof(*acmod));
acmod->config = ps_config_retain(config);
acmod->lmath = logmath_retain(lmath);
acmod->state = ACMOD_IDLE;
/* Initialize or retain fe and fcb. */
if (acmod_reinit_feat(acmod, fe, fcb) < 0)
goto error_out;
/* Load acoustic model parameters. */
if (acmod_init_am(acmod) < 0)
goto error_out;
/* Senone computation stuff. */
acmod->senone_scores = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_scores));
acmod->senone_active_vec = bitvec_alloc(bin_mdef_n_sen(acmod->mdef));
acmod->senone_active = ckd_calloc(bin_mdef_n_sen(acmod->mdef),
sizeof(*acmod->senone_active));
acmod->log_zero = logmath_get_zero(acmod->lmath);
acmod->compallsen = ps_config_bool(config, "compallsen");
return acmod;
error_out:
acmod_free(acmod);
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, %edi
movl $0xc8, %esi
leaq 0x52697(%rip), %rdx # 0x7aa00
movl $0xff, %ecx
callq 0x23c10
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13410
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x25970
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0xa8(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x27d10
cmpl $0x0, %eax
jge 0x283c4
jmp 0x284aa
movq -0x30(%rbp), %rdi
callq 0x284d0
cmpl $0x0, %eax
jge 0x283d7
jmp 0x284aa
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movslq 0x14(%rax), %rdi
movl $0x2, %esi
leaq 0x52611(%rip), %rdx # 0x7aa00
movl $0x10e, %ecx # imm = 0x10E
callq 0x23c10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x14(%rax), %eax
addl $0x20, %eax
subl $0x1, %eax
movl $0x20, %ecx
cltd
idivl %ecx
movslq %eax, %rdi
movl $0x4, %esi
leaq 0x525d4(%rip), %rdx # 0x7aa00
movl $0x10f, %ecx # imm = 0x10F
callq 0x23c10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movslq 0x14(%rax), %rdi
movl $0x1, %esi
leaq 0x525a7(%rip), %rdx # 0x7aa00
movl $0x111, %ecx # imm = 0x111
callq 0x23c10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x25a20
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
leaq 0x4dad6(%rip), %rsi # 0x75f65
callq 0x143f0
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0xa9(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x284bb
movq -0x30(%rbp), %rdi
callq 0x28880
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_init_am | static int
acmod_init_am(acmod_t *acmod)
{
char const *mdeffn, *tmatfn, *mllrfn, *hmmdir;
/* Read model definition. */
if ((mdeffn = ps_config_str(acmod->config, "mdef")) == NULL) {
if ((hmmdir = ps_config_str(acmod->config, "hmm")) == NULL)
E_ERROR("Acoustic model definition is not specified either "
"with -mdef option or with -hmm\n");
else
E_ERROR("Folder '%s' does not contain acoustic model "
"definition 'mdef'\n", hmmdir);
return -1;
}
if ((acmod->mdef = bin_mdef_read(acmod->config, mdeffn)) == NULL) {
E_ERROR("Failed to read acoustic model definition from %s\n", mdeffn);
return -1;
}
/* Read transition matrices. */
if ((tmatfn = ps_config_str(acmod->config, "tmat")) == NULL) {
E_ERROR("No tmat file specified\n");
return -1;
}
acmod->tmat = tmat_init(tmatfn, acmod->lmath,
ps_config_float(acmod->config, "tmatfloor"),
TRUE);
/* Read the acoustic models. */
if ((ps_config_str(acmod->config, "mean") == NULL)
|| (ps_config_str(acmod->config, "var") == NULL)
|| (ps_config_str(acmod->config, "tmat") == NULL)) {
E_ERROR("No mean/var/tmat files specified\n");
return -1;
}
if (ps_config_str(acmod->config, "senmgau")) {
E_INFO("Using general multi-stream GMM computation\n");
acmod->mgau = ms_mgau_init(acmod, acmod->lmath, acmod->mdef);
if (acmod->mgau == NULL)
return -1;
}
else {
E_INFO("Attempting to use PTM computation module\n");
if ((acmod->mgau = ptm_mgau_init(acmod, acmod->mdef)) == NULL) {
E_INFO("Attempting to use semi-continuous computation module\n");
if ((acmod->mgau = s2_semi_mgau_init(acmod)) == NULL) {
E_INFO("Falling back to general multi-stream GMM computation\n");
acmod->mgau = ms_mgau_init(acmod, acmod->lmath, acmod->mdef);
if (acmod->mgau == NULL) {
E_ERROR("Failed to read acoustic model\n");
return -1;
}
}
}
}
/* If there is an MLLR transform, apply it. */
if ((mllrfn = ps_config_str(acmod->config, "mllr"))) {
ps_mllr_t *mllr = ps_mllr_read(mllrfn);
if (mllr == NULL)
return -1;
acmod_update_mllr(acmod, mllr);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d3d9(%rip), %rsi # 0x758c3
callq 0x13700
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x28566
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d353(%rip), %rsi # 0x7585a
callq 0x13700
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x28537
movl $0x3, %edi
leaq 0x524de(%rip), %rsi # 0x7aa00
movl $0x46, %edx
leaq 0x52797(%rip), %rcx # 0x7acc5
movb $0x0, %al
callq 0x23450
jmp 0x2855a
movq -0x30(%rbp), %r8
movl $0x3, %edi
leaq 0x524b9(%rip), %rsi # 0x7aa00
movl $0x49, %edx
leaq 0x527c4(%rip), %rcx # 0x7ad17
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2e360
movq -0x10(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0x285b3
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x5246c(%rip), %rsi # 0x7aa00
movl $0x4f, %edx
leaq 0x527b6(%rip), %rcx # 0x7ad56
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x573a7(%rip), %rsi # 0x7f968
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x285fb
movl $0x3, %edi
leaq 0x52424(%rip), %rsi # 0x7aa00
movl $0x55, %edx
leaq 0x527a0(%rip), %rcx # 0x7ad88
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d331(%rip), %rsi # 0x7594e
callq 0x14430
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x1, %edx
callq 0x63930
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d351(%rip), %rsi # 0x7599e
callq 0x13700
cmpq $0x0, %rax
je 0x2868a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d35f(%rip), %rsi # 0x759c5
callq 0x13700
cmpq $0x0, %rax
je 0x2868a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x572e9(%rip), %rsi # 0x7f968
callq 0x13700
cmpq $0x0, %rax
jne 0x286b5
movl $0x3, %edi
leaq 0x5236a(%rip), %rsi # 0x7aa00
movl $0x60, %edx
leaq 0x526fe(%rip), %rcx # 0x7ada0
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d221(%rip), %rsi # 0x758e4
callq 0x13700
cmpq $0x0, %rax
je 0x2872d
movl $0x1, %edi
leaq 0x52326(%rip), %rsi # 0x7aa00
movl $0x65, %edx
leaq 0x526dc(%rip), %rcx # 0x7adc2
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x4df00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x28728
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
jmp 0x28821
movl $0x1, %edi
leaq 0x522c7(%rip), %rsi # 0x7aa00
movl $0x6b, %edx
leaq 0x526a9(%rip), %rcx # 0x7adee
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x5c440
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0x2881f
movl $0x1, %edi
leaq 0x52285(%rip), %rsi # 0x7aa00
movl $0x6d, %edx
leaq 0x52691(%rip), %rcx # 0x7ae18
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
callq 0x5f100
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0x2881d
movl $0x1, %edi
leaq 0x5224f(%rip), %rsi # 0x7aa00
movl $0x6f, %edx
leaq 0x52691(%rip), %rcx # 0x7ae4e
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x4df00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x2881b
movl $0x3, %edi
leaq 0x52201(%rip), %rsi # 0x7aa00
movl $0x72, %edx
leaq 0x52679(%rip), %rcx # 0x7ae84
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
jmp 0x2881d
jmp 0x2881f
jmp 0x28821
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4d2fa(%rip), %rsi # 0x75b29
callq 0x13700
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28868
movq -0x28(%rbp), %rdi
callq 0x1a010
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2885b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2886f
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x28a10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_free | void
acmod_free(acmod_t *acmod)
{
if (acmod == NULL)
return;
feat_free(acmod->fcb);
fe_free(acmod->fe);
ps_config_free(acmod->config);
if (acmod->mfc_buf)
ckd_free_2d((void **)acmod->mfc_buf);
if (acmod->feat_buf)
feat_array_free(acmod->feat_buf);
if (acmod->mfcfh)
fclose(acmod->mfcfh);
if (acmod->rawfh)
fclose(acmod->rawfh);
if (acmod->senfh)
fclose(acmod->senfh);
ckd_free(acmod->framepos);
ckd_free(acmod->senone_scores);
ckd_free(acmod->senone_active_vec);
ckd_free(acmod->senone_active);
if (acmod->mdef)
bin_mdef_free(acmod->mdef);
if (acmod->tmat)
tmat_free(acmod->tmat);
if (acmod->mgau)
ps_mgau_free(acmod->mgau);
if (acmod->mllr)
ps_mllr_free(acmod->mllr);
logmath_free(acmod->lmath);
ckd_free(acmod);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x28898
jmp 0x28a01
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x39d30
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x33dc0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13430
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x288d6
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x23e60
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x288ee
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x36db0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x2890c
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x7120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x2892a
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x7120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x28948
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x7120
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x23e40
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x23e40
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x23e40
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x23e40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x28997
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2e220
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x289af
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x642a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x289d3
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x289eb
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1a5b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x255e0
movq -0x8(%rbp), %rdi
callq 0x23e40
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_set_senfh | int
acmod_set_senfh(acmod_t *acmod, FILE *logfh)
{
if (acmod->senfh)
fclose(acmod->senfh);
acmod->senfh = logfh;
if (logfh == NULL)
return 0;
return acmod_write_senfh_header(acmod, logfh);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x28b9e
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x7120
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x28bbd
movl $0x0, -0x4(%rbp)
jmp 0x28bcd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28a80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_grow_feat_buf | void
acmod_grow_feat_buf(acmod_t *acmod, int nfr)
{
if (nfr > MAX_N_FRAMES)
E_FATAL("Decoder can not process more than %d frames at once, "
"requested %d\n", MAX_N_FRAMES, nfr);
acmod->feat_buf = feat_array_realloc(acmod->fcb, acmod->feat_buf,
acmod->n_feat_alloc, nfr);
acmod->framepos = ckd_realloc(acmod->framepos,
nfr * sizeof(*acmod->framepos));
acmod->n_feat_alloc = nfr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jle 0x28ced
jmp 0x28cba
movl -0xc(%rbp), %r9d
movl $0x4, %edi
leaq 0x51d36(%rip), %rsi # 0x7aa00
movl $0x181, %edx # imm = 0x181
leaq 0x51e4c(%rip), %rcx # 0x7ab22
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
callq 0x7410
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %edx
movl -0xc(%rbp), %ecx
callq 0x36bf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movslq -0xc(%rbp), %rsi
shlq $0x3, %rsi
leaq 0x51ccc(%rip), %rdx # 0x7aa00
movl $0x186, %ecx # imm = 0x186
callq 0x23cc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xbc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_end_utt | int
acmod_end_utt(acmod_t *acmod)
{
int32 nfr = 0;
acmod->state = ACMOD_ENDED;
if (acmod->n_mfc_frame < acmod->n_mfc_alloc) {
int inptr;
/* Where to start writing them (circular buffer) */
inptr = (acmod->mfc_outidx + acmod->n_mfc_frame) % acmod->n_mfc_alloc;
/* nfr is always either zero or one. */
fe_end_utt(acmod->fe, acmod->mfc_buf[inptr], &nfr);
acmod->n_mfc_frame += nfr;
/* Process whatever's left, and any leadout. */
if (nfr)
nfr = acmod_process_mfcbuf(acmod);
else /* Make sure to update CMN! */
feat_update_stats(acmod->fcb);
}
else /* Make sure to update CMN! */
feat_update_stats(acmod->fcb);
if (acmod->mfcfh) {
int32 outlen, rv;
outlen = (ftell(acmod->mfcfh) - 4) / 4;
SWAP_BE_32(&outlen);
/* Try to seek and write */
if ((rv = fseek(acmod->mfcfh, 0, SEEK_SET)) == 0) {
fwrite(&outlen, 4, 1, acmod->mfcfh);
}
fclose(acmod->mfcfh);
acmod->mfcfh = NULL;
}
if (acmod->rawfh) {
fclose(acmod->rawfh);
acmod->rawfh = NULL;
}
if (acmod->senfh) {
fclose(acmod->senfh);
acmod->senfh = NULL;
}
return nfr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x3, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xb0(%rcx), %eax
jge 0x28f0d
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0xb4(%rcx), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0xb0(%rcx)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0xc(%rbp), %rdx
callq 0x349e0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0xb4(%rax), %ecx
movl %ecx, 0xb4(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x28efe
movq -0x8(%rbp), %rdi
callq 0x29050
movl %eax, -0xc(%rbp)
jmp 0x28f0b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x39cc0
jmp 0x28f1a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x39cc0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x28fe0
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x7290
subq $0x4, %rax
movl $0x4, %ecx
cqto
idivq %rcx
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x14(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x14(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7310
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jne 0x28fc1
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x7420
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x7120
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x2900d
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x7120
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x2903a
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x7120
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/acmod.c |
acmod_process_full_raw | static int
acmod_process_full_raw(acmod_t *acmod,
int16 const **inout_raw,
size_t *inout_n_samps)
{
int32 nfr, ntail;
mfcc_t **cepptr;
/* Write to logging file if any. */
if (acmod->rawfh)
fwrite(*inout_raw, 2, *inout_n_samps, acmod->rawfh);
/* Resize mfc_buf to fit. */
if (fe_process_frames(acmod->fe, NULL, inout_n_samps, NULL, &nfr) < 0)
return -1;
if (acmod->n_mfc_alloc < nfr + 1) {
ckd_free_2d(acmod->mfc_buf);
acmod->mfc_buf = ckd_calloc_2d(nfr + 1, fe_get_output_size(acmod->fe),
sizeof(**acmod->mfc_buf));
acmod->n_mfc_alloc = nfr + 1;
}
acmod->n_mfc_frame = 0;
acmod->mfc_outidx = 0;
fe_start_utt(acmod->fe);
if (fe_process_frames(acmod->fe, inout_raw, inout_n_samps,
acmod->mfc_buf, &nfr) < 0)
return -1;
fe_end_utt(acmod->fe, acmod->mfc_buf[nfr], &ntail);
nfr += ntail;
cepptr = acmod->mfc_buf;
nfr = acmod_process_full_cep(acmod, &cepptr, &nfr);
acmod->n_mfc_frame = 0;
return nfr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29495
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
movl $0x2, %esi
callq 0x7420
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x24(%rbp), %r8
movq %rcx, %rsi
callq 0x348d0
cmpl $0x0, %eax
jge 0x294c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x295eb
movq -0x10(%rbp), %rax
movl 0xb0(%rax), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x29535
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x23e60
movl -0x24(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x341c0
movq -0x38(%rbp), %rdi
movslq %eax, %rsi
movl $0x4, %edx
leaq 0x514f1(%rip), %rcx # 0x7aa00
movl $0x223, %r8d # imm = 0x223
callq 0x23d90
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xb4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x34150
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
leaq -0x24(%rbp), %r8
callq 0x348d0
cmpl $0x0, %eax
jge 0x2958d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x295eb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x28(%rbp), %rdx
callq 0x349e0
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x29a10
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0xb4(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/acmod.c |
allphone_search_fill_iter | static void
allphone_search_fill_iter(ps_seg_t *seg, phseg_t *phseg)
{
seg->sf = phseg->sf;
seg->ef = phseg->ef;
seg->ascr = phseg->score;
seg->lscr = phseg->tscore;
seg->text = bin_mdef_ciphone_str(ps_search_acmod(seg->search)->mdef, phseg->ci);
seg->wid = BAD_S3WID;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movswl (%rax), %esi
callq 0x30320
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
| /cmusphinx[P]pocketsphinx/src/allphone_search.c |
ngram_fwdtree_search | int
ngram_fwdtree_search(ngram_search_t *ngs, int frame_idx)
{
int16 const *senscr;
/* Activate our HMMs for the current frame if need be. */
if (!ps_search_acmod(ngs)->compallsen)
compute_sen_active(ngs, frame_idx);
/* Compute GMM scores for the current frame. */
if ((senscr = acmod_score(ps_search_acmod(ngs), &frame_idx)) == NULL)
return 0;
ngs->st.n_senone_active_utt += ps_search_acmod(ngs)->n_senone_active;
/* Mark backpointer table for current frame. */
ngram_search_mark_bptable(ngs, frame_idx);
/* If the best score is equal to or worse than WORST_SCORE,
* recognition has failed, don't bother to keep trying. */
if (ngs->best_score == WORST_SCORE || ngs->best_score WORSE_THAN WORST_SCORE)
return 0;
/* Renormalize if necessary */
if (ngs->best_score + (2 * ngs->beam) WORSE_THAN WORST_SCORE) {
E_INFO("Renormalizing Scores at frame %d, best score %d\n",
frame_idx, ngs->best_score);
renormalize_scores(ngs, frame_idx, ngs->best_score);
}
/* Evaluate HMMs */
evaluate_channels(ngs, senscr, frame_idx);
/* Prune HMMs and do phone transitions. */
prune_channels(ngs, frame_idx);
/* Do absolute pruning on word exits. */
bptable_maxwpf(ngs, frame_idx);
/* Do word transitions. */
word_transition(ngs, frame_idx);
/* Deactivate pruned HMMs. */
deactivate_channels(ngs, frame_idx);
++ngs->n_frame;
/* Return the number of frames processed. */
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpb $0x0, 0xa9(%rax)
jne 0x577fc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x57940
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2a970
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x57823
movl $0x0, -0x4(%rbp)
jmp 0x57933
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x64(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x1d8(%rax), %ecx
movl %ecx, 0x1d8(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x50710
movq -0x10(%rbp), %rax
cmpl $0xe0000000, 0x1a0(%rax) # imm = 0xE0000000
je 0x5786a
movq -0x10(%rbp), %rax
cmpl $0xe0000000, 0x1a0(%rax) # imm = 0xE0000000
jge 0x57876
movl $0x0, -0x4(%rbp)
jmp 0x57933
movq -0x10(%rbp), %rax
movl 0x1a0(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x28c(%rcx), %ecx
shll %ecx
addl %ecx, %eax
cmpl $0xe0000000, %eax # imm = 0xE0000000
jge 0x578d9
movl -0x14(%rbp), %r8d
movq -0x10(%rbp), %rax
movl 0x1a0(%rax), %r9d
movl $0x1, %edi
leaq 0x29616(%rip), %rsi # 0x80ec6
movl $0x5c5, %edx # imm = 0x5C5
leaq 0x21e9f(%rip), %rcx # 0x7975b
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x1a0(%rax), %edx
callq 0x57b60
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x57d70
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x57e20
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x58100
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x58300
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x58d20
movq -0x10(%rbp), %rax
movl 0x15c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x15c(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/ngram_search_fwdtree.c |
kws_detections_add | void
kws_detections_add(kws_detections_t *detections, const char* keyphrase, int sf, int ef, int prob, int ascr)
{
gnode_t *gn;
kws_detection_t* detection;
for (gn = detections->detect_list; gn; gn = gnode_next(gn)) {
kws_detection_t *det = (kws_detection_t *)gnode_ptr(gn);
if (strcmp(keyphrase, det->keyphrase) == 0 && det->sf < ef && det->ef > sf) {
if (det->prob < prob) {
det->sf = sf;
det->ef = ef;
det->prob = prob;
det->ascr = ascr;
}
return;
}
}
/* Nothing found */
detection = (kws_detection_t *)ckd_calloc(1, sizeof(*detection));
detection->sf = sf;
detection->ef = ef;
detection->keyphrase = keyphrase;
detection->prob = prob;
detection->ascr = ascr;
detections->detect_list = glist_add_ptr(detections->detect_list, detection);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6c4f5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x7260
cmpl $0x0, %eax
jne 0x6c4e2
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jge 0x6c4e2
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x6c4e2
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6c4e0
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x6c561
jmp 0x6c4e4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6c469
movl $0x1, %edi
movl $0x18, %esi
leaq 0x1689e(%rip), %rdx # 0x82da4
movl $0x4a, %ecx
callq 0x23c10
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x25e50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/kws_detections.c |
ngram_model_trie_read_dmp | ngram_model_t *
ngram_model_trie_read_dmp(ps_config_t * config,
const char *file_name, logmath_t * lmath)
{
uint8 do_swap;
int32 is_pipe;
int32 k;
uint32 j;
int32 vn, ts;
int32 count;
uint32 counts[3];
uint32 *unigram_next;
int order;
char str[1024];
FILE *fp;
ngram_model_trie_t *model;
ngram_model_t *base;
ngram_raw_t **raw_ngrams;
(void)config;
E_INFO("Trying to read LM in dmp format\n");
if ((fp = fopen_comp(file_name, "rb", &is_pipe)) == NULL) {
E_ERROR("Dump file %s not found\n", file_name);
return NULL;
}
do_swap = FALSE;
fread(&k, sizeof(k), 1, fp);
if (k != strlen(dmp_hdr) + 1) {
SWAP_INT32(&k);
if (k != strlen(dmp_hdr) + 1) {
E_ERROR
("Wrong magic header size number %x: %s is not a dump file\n",
k, file_name);
return NULL;
}
do_swap = 1;
}
if (fread(str, 1, k, fp) != (size_t) k) {
E_ERROR("Cannot read header\n");
return NULL;
}
if (strncmp(str, dmp_hdr, k) != 0) {
E_ERROR("Wrong header %s: %s is not a dump file\n", dmp_hdr);
return NULL;
}
if (fread(&k, sizeof(k), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&k);
if (fread(str, 1, k, fp) != (size_t) k) {
E_ERROR("Cannot read LM filename in header\n");
return NULL;
}
/* read version#, if present (must be <= 0) */
if (fread(&vn, sizeof(vn), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&vn);
if (vn <= 0) {
/* read and don't compare timestamps (we don't care) */
if (fread(&ts, sizeof(ts), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&ts);
/* read and skip format description */
for (;;) {
if (fread(&k, sizeof(k), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&k);
if (k == 0)
break;
if (fread(str, 1, k, fp) != (size_t) k) {
E_ERROR("Failed to read word\n");
return NULL;
}
}
/* read model->ucount */
if (fread(&count, sizeof(count), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&count);
counts[0] = count;
}
else {
counts[0] = vn;
}
/* read model->bcount, tcount */
if (fread(&count, sizeof(count), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&count);
counts[1] = count;
if (fread(&count, sizeof(count), 1, fp) != 1)
return NULL;
if (do_swap)
SWAP_INT32(&count);
counts[2] = count;
E_INFO("ngrams 1=%d, 2=%d, 3=%d\n", counts[0], counts[1], counts[2]);
model = (ngram_model_trie_t *) ckd_calloc(1, sizeof(*model));
base = &model->base;
if (counts[2] > 0)
order = 3;
else if (counts[1] > 0)
order = 2;
else
order = 1;
ngram_model_init(base, &ngram_model_trie_funcs, lmath, order,
(int32) counts[0]);
model->trie = lm_trie_create(counts[0], order);
unigram_next =
(uint32 *) ckd_calloc((int32) counts[0] + 1, sizeof(unigram_next));
for (j = 0; j <= counts[0]; j++) {
int32 bigrams;
int32 mapid;
dmp_weight_t weightp;
dmp_weight_t weightb;
/* Skip over the mapping ID, we don't care about it. */
/* Read the weights from actual unigram structure. */
fread(&mapid, sizeof(int32), 1, fp);
fread(&weightp, sizeof(weightp), 1, fp);
fread(&weightb, sizeof(weightb), 1, fp);
fread(&bigrams, sizeof(int32), 1, fp);
if (do_swap) {
SWAP_INT32(&weightp.l);
SWAP_INT32(&weightb.l);
SWAP_INT32(&bigrams);
}
model->trie->unigrams[j].prob = logmath_log10_to_log_float(lmath, weightp.f);
model->trie->unigrams[j].bo = logmath_log10_to_log_float(lmath, weightb.f);
model->trie->unigrams[j].next = bigrams;
unigram_next[j] = bigrams;
}
if (order > 1) {
raw_ngrams =
ngrams_raw_read_dmp(fp, lmath, counts, order, unigram_next,
do_swap);
if (raw_ngrams == NULL) {
ngram_model_free(base);
ckd_free(unigram_next);
fclose_comp(fp, is_pipe);
return NULL;
}
lm_trie_build(model->trie, raw_ngrams, counts, base->n_counts, order);
ngrams_raw_free(raw_ngrams, counts, order);
}
/* Sentinel unigram and bigrams read before */
ckd_free(unigram_next);
/* read ascii word strings */
read_word_str(base, fp, do_swap);
fclose_comp(fp, is_pipe);
return base;
} | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
leaq 0x15451(%rip), %rsi # 0x82e04
movl $0x1cf, %edx # imm = 0x1CF
leaq 0x15672(%rip), %rcx # 0x83031
movb $0x0, %al
callq 0x23450
movq -0x18(%rbp), %rdi
leaq 0x9a5b(%rip), %rsi # 0x7742c
leaq -0x28(%rbp), %rdx
callq 0x26b30
movq %rax, -0x468(%rbp)
cmpq $0x0, %rax
jne 0x6da17
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x1540d(%rip), %rsi # 0x82e04
movl $0x1d1, %edx # imm = 0x1D1
leaq 0x1564f(%rip), %rcx # 0x83052
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
movb $0x0, -0x21(%rbp)
movq -0x468(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
movslq -0x2c(%rbp), %rax
cmpq $0x11, %rax
je 0x6dab9
movl -0x2c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x2c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x2c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x2c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq $0x11, %rax
je 0x6dab5
movl -0x2c(%rbp), %r8d
movq -0x18(%rbp), %r9
movl $0x3, %edi
leaq 0x1536f(%rip), %rsi # 0x82e04
movl $0x1dc, %edx # imm = 0x1DC
leaq 0x155c9(%rip), %rcx # 0x8306a
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
movb $0x1, -0x21(%rbp)
leaq -0x460(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x1, %esi
callq 0x70f0
movslq -0x2c(%rbp), %rcx
cmpq %rcx, %rax
je 0x6db0a
movl $0x3, %edi
leaq 0x1531a(%rip), %rsi # 0x82e04
movl $0x1e2, %edx # imm = 0x1E2
leaq 0x155ae(%rip), %rcx # 0x830a4
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
leaq -0x460(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
leaq 0x15834(%rip), %rsi # 0x83350
callq 0x7090
cmpl $0x0, %eax
je 0x6db59
movl $0x3, %edi
leaq 0x152d2(%rip), %rsi # 0x82e04
movl $0x1e6, %edx # imm = 0x1E6
leaq 0x1557a(%rip), %rcx # 0x830b8
leaq 0x1580b(%rip), %r8 # 0x83350
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
movq -0x468(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6db86
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6dbc4
movl -0x2c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x2c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x2c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x2c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
leaq -0x460(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x1, %esi
callq 0x70f0
movslq -0x2c(%rbp), %rcx
cmpq %rcx, %rax
je 0x6dc15
movl $0x3, %edi
leaq 0x1520f(%rip), %rsi # 0x82e04
movl $0x1ef, %edx # imm = 0x1EF
leaq 0x154df(%rip), %rcx # 0x830e0
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
movq -0x468(%rbp), %rcx
leaq -0x34(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6dc42
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6dc80
movl -0x34(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x34(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x34(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x34(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jg 0x6de33
movq -0x468(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6dcb7
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6dcf5
movl -0x38(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x38(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x38(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x38(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x6dcf7
movq -0x468(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6dd24
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6dd62
movl -0x2c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x2c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x2c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x2c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6dd6a
jmp 0x6ddc0
leaq -0x460(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
movq -0x468(%rbp), %rcx
movl $0x1, %esi
callq 0x70f0
movslq -0x2c(%rbp), %rcx
cmpq %rcx, %rax
je 0x6ddbb
movl $0x3, %edi
leaq 0x15069(%rip), %rsi # 0x82e04
movl $0x208, %edx # imm = 0x208
leaq 0x1535c(%rip), %rcx # 0x83103
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
jmp 0x6dcf7
movq -0x468(%rbp), %rcx
leaq -0x3c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6dded
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6de2b
movl -0x3c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x3c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x3c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x3c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x6de39
movl -0x34(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x468(%rbp), %rcx
leaq -0x3c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6de66
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6dea4
movl -0x3c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x3c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x3c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x3c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x468(%rbp), %rcx
leaq -0x3c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpq $0x1, %rax
je 0x6ded7
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
cmpb $0x0, -0x21(%rbp)
je 0x6df15
movl -0x3c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x3c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x3c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x3c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x48(%rbp), %r8d
movl -0x44(%rbp), %r9d
movl -0x40(%rbp), %eax
movl $0x1, %edi
leaq 0x14ed2(%rip), %rsi # 0x82e04
movl $0x221, %edx # imm = 0x221
leaq 0x151da(%rip), %rcx # 0x83118
movl %eax, (%rsp)
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
movl $0x68, %esi
leaq 0x14eab(%rip), %rdx # 0x82e04
movl $0x223, %ecx # imm = 0x223
callq 0x23c10
movq %rax, -0x470(%rbp)
movq -0x470(%rbp), %rax
movq %rax, -0x478(%rbp)
cmpl $0x0, -0x40(%rbp)
jbe 0x6df87
movl $0x3, -0x54(%rbp)
jmp 0x6df9f
cmpl $0x0, -0x44(%rbp)
jbe 0x6df96
movl $0x2, -0x54(%rbp)
jmp 0x6df9d
movl $0x1, -0x54(%rbp)
jmp 0x6df9f
movq -0x478(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x54(%rbp), %ecx
movl -0x48(%rbp), %r8d
leaq 0x26778(%rip), %rsi # 0x94730
callq 0x48460
movl -0x48(%rbp), %edi
movl -0x54(%rbp), %esi
callq 0x6fcd0
movq %rax, %rcx
movq -0x470(%rbp), %rax
movq %rcx, 0x60(%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x8, %esi
leaq 0x14e19(%rip), %rdx # 0x82e04
movl $0x231, %ecx # imm = 0x231
callq 0x23c10
movq %rax, -0x50(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x48(%rbp), %eax
ja 0x6e204
movq -0x468(%rbp), %rcx
leaq -0x488(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
movq -0x468(%rbp), %rcx
leaq -0x48c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
movq -0x468(%rbp), %rcx
leaq -0x490(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
movq -0x468(%rbp), %rcx
leaq -0x484(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x70f0
cmpb $0x0, -0x21(%rbp)
je 0x6e15f
movl -0x48c(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x48c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x48c(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x48c(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x48c(%rbp)
movl -0x490(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x490(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x490(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x490(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x490(%rbp)
movl -0x484(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl -0x484(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x484(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x484(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x484(%rbp)
movq -0x20(%rbp), %rdi
movss -0x48c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x25d50
movq -0x470(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rdi
movss -0x490(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x25d50
movq -0x470(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movss %xmm0, 0x4(%rax)
movl -0x484(%rbp), %ecx
movq -0x470(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %edx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x484(%rbp), %edx
movq -0x50(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6e000
cmpl $0x1, -0x54(%rbp)
jle 0x6e2aa
movq -0x468(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movl -0x54(%rbp), %ecx
movq -0x50(%rbp), %r8
movzbl -0x21(%rbp), %r9d
callq 0x6eb70
movq %rax, -0x480(%rbp)
cmpq $0x0, -0x480(%rbp)
jne 0x6e26d
movq -0x478(%rbp), %rdi
callq 0x48680
movq -0x50(%rbp), %rdi
callq 0x23e40
movq -0x468(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x26f80
movq $0x0, -0x8(%rbp)
jmp 0x6e2e4
movq -0x470(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x480(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq -0x478(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x54(%rbp), %r8d
callq 0x70400
movq -0x480(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl -0x54(%rbp), %edx
callq 0x6ead0
movq -0x50(%rbp), %rdi
callq 0x23e40
movq -0x478(%rbp), %rdi
movq -0x468(%rbp), %rsi
movzbl -0x21(%rbp), %edx
callq 0x6d4f0
movq -0x468(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x26f80
movq -0x478(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x4a0, %rsp # imm = 0x4A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/ngram_model_trie.c |
ngram_model_trie_raw_score | static int32
ngram_model_trie_raw_score(ngram_model_t * base, int32 wid, int32 * hist,
int32 n_hist, int32 * n_used)
{
int32 i;
ngram_model_trie_t *model = (ngram_model_trie_t *) base;
if (n_hist > model->base.n - 1)
n_hist = model->base.n - 1;
for (i = 0; i < n_hist; i++) {
if (hist[i] < 0) {
n_hist = i;
break;
}
}
return (int32) lm_trie_score(model->trie, model->base.n, wid, hist,
n_hist, n_used);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x6e412
movq -0x38(%rbp), %rax
movzbl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6e444
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x6e437
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e444
jmp 0x6e439
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6e419
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x38(%rbp), %rax
movzbl 0x18(%rax), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x70c10
cvttss2si %xmm0, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/ngram_model_trie.c |
middle_init | void
middle_init(middle_t * middle, void *base_mem, uint8 quant_bits,
uint32 entries, uint32 max_vocab, uint32 max_next,
void *next_source)
{
middle->quant_bits = quant_bits;
bitarr_mask_from_max(&middle->next_mask, max_next);
middle->next_source = next_source;
if (entries + 1 >= (1U << 25) || (max_next >= (1U << 25)))
E_ERROR
("Sorry, this does not support more than %d n-grams of a particular order. Edit util/bit_packing.hh and fix the bit packing functions\n",
(1U << 25));
base_init(&middle->base, base_mem, max_vocab,
quant_bits + middle->next_mask.bits);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq 0x10(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x20(%rbp), %esi
callq 0x74980
movq 0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl $0x2000000, %eax # imm = 0x2000000
jae 0x6f880
cmpl $0x2000000, -0x20(%rbp) # imm = 0x2000000
jb 0x6f8a5
movl $0x3, %edi
leaq 0x13ccf(%rip), %rsi # 0x8355b
movl $0x6f, %edx
leaq 0x13d1f(%rip), %rcx # 0x835b7
movl $0x2000000, %r8d # imm = 0x2000000
movb $0x0, %al
callq 0x23450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movzbl -0x11(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
addl %ecx, %eax
movzbl %al, %ecx
callq 0x6f8d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
lm_trie_read_ug | static size_t
lm_trie_read_ug(lm_trie_t * trie, uint32 * counts, FILE * fp)
{
size_t rv = fread(trie->unigrams, sizeof(*trie->unigrams),
(counts[0] + 1), fp);
if (SWAP_LM_TRIE) {
int i;
for (i = 0; (uint32)i < counts[0] + 1; ++i) {
SWAP_FLOAT32(&trie->unigrams[i].prob);
SWAP_FLOAT32(&trie->unigrams[i].bo);
SWAP_INT32(&trie->unigrams[i].next);
}
}
return rv;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movl $0xc, %esi
callq 0x70f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
lm_trie_build | void
lm_trie_build(lm_trie_t * trie, ngram_raw_t ** raw_ngrams, uint32 * counts, uint32 *out_counts,
int order)
{
int i;
lm_trie_fix_counts(raw_ngrams, counts, out_counts, order);
lm_trie_alloc_ngram(trie, out_counts, order);
if (order > 1)
E_INFO("Training quantizer\n");
for (i = 2; i < order; i++) {
lm_trie_quant_train(trie->quant, i, counts[i - 1],
raw_ngrams[i - 2]);
}
lm_trie_quant_train_prob(trie->quant, order, counts[order - 1],
raw_ngrams[order - 2]);
E_INFO("Building LM trie\n");
recursive_insert(trie, raw_ngrams, counts, order);
/* Set ending offsets so the last entry will be sized properly */
/* Last entry for unigrams was already set. */
if (trie->middle_begin != trie->middle_end) {
middle_t *middle_ptr;
for (middle_ptr = trie->middle_begin;
middle_ptr != trie->middle_end - 1; ++middle_ptr) {
middle_t *next_middle_ptr = middle_ptr + 1;
middle_finish_loading(middle_ptr,
next_middle_ptr->base.insert_index);
}
middle_ptr = trie->middle_end - 1;
middle_finish_loading(middle_ptr,
trie->longest->base.insert_index);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x6f9c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x6ff30
cmpl $0x1, -0x24(%rbp)
jle 0x70465
movl $0x1, %edi
leaq 0x13109(%rip), %rsi # 0x8355b
movl $0x20a, %edx # imm = 0x20A
leaq 0x1327b(%rip), %rcx # 0x836d9
movb $0x0, %al
callq 0x23450
movl $0x2, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x704b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x28(%rbp), %esi
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
callq 0x740b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7046c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
callq 0x74370
movl $0x1, %edi
leaq 0x1306e(%rip), %rsi # 0x8355b
movl $0x212, %edx # imm = 0x212
leaq 0x131f4(%rip), %rcx # 0x836ed
movb $0x0, %al
callq 0x23450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x705a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x70595
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
addq $-0x30, %rcx
cmpq %rcx, %rax
je 0x70571
movq -0x30(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x70b60
movq -0x30(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x30(%rbp)
jmp 0x70532
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $-0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %esi
callq 0x70b60
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
middle_finish_loading | static void
middle_finish_loading(middle_t * middle, uint32 next_end)
{
bitarr_address_t address;
address.base = middle->base.base;
address.offset =
(middle->base.insert_index + 1) * middle->base.total_bits -
middle->next_mask.bits;
bitarr_write_int25(address, middle->next_mask.bits, next_end);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
imull %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movzbl %al, %edx
callq 0x74930
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
unigram_next | static uint32
unigram_next(lm_trie_t * trie, int order)
{
return order ==
2 ? trie->longest->base.insert_index : trie->middle_begin->base.
insert_index;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x71541
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x7154f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
longest_insert | static bitarr_address_t
longest_insert(longest_t * longest, uint32 index)
{
bitarr_address_t address;
assert(index <= longest->base.word_mask);
address.base = longest->base.base;
address.offset = longest->base.insert_index * longest->base.total_bits;
bitarr_write_int25(address, longest->base.word_bits, index);
address.offset += longest->base.word_bits;
longest->base.insert_index++;
return address;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
ja 0x7167d
jmp 0x7169c
leaq 0x12259(%rip), %rdi # 0x838dd
leaq 0x11ed0(%rip), %rsi # 0x8355b
movl $0x99, %edx
leaq 0x12267(%rip), %rcx # 0x838fe
callq 0x71c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
movzbl 0x1(%rcx), %ecx
imull %ecx, %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %edx
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x74930
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movl -0x8(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
incl %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/lm_trie.c |
gauden_dist | int32
gauden_dist(gauden_t * g,
int mgau, int32 n_top, mfcc_t** obs, gauden_dist_t ** out_dist)
{
int32 f;
assert((n_top > 0) && (n_top <= g->n_density));
for (f = 0; f < g->n_feat; f++) {
compute_dist(out_dist[f], n_top,
obs[f], g->featlen[f],
g->mean[mgau][f], g->var[mgau][f], g->det[mgau][f],
g->n_density);
E_DEBUG("Top CW(%d,%d) = %d %d\n", mgau, f, out_dist[f][0].id,
(int)out_dist[f][0].dist >> SENSCR_SHIFT);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x72cae
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jg 0x72cae
jmp 0x72ccd
leaq 0x10e00(%rip), %rdi # 0x83ab5
leaq 0x10c77(%rip), %rsi # 0x83933
movl $0x1f1, %edx # imm = 0x1F1
leaq 0x10e14(%rip), %rcx # 0x83adc
callq 0x71c0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jge 0x72d77
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %r8
movq (%rax,%r8,8), %rax
movslq -0x24(%rbp), %r8
movq (%rax,%r8,8), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %r9
movq (%rax,%r9,8), %rax
movslq -0x24(%rbp), %r9
movq (%rax,%r9,8), %r9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %r10
movq (%rax,%r10,8), %rax
movslq -0x24(%rbp), %r10
movq (%rax,%r10,8), %r10
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x72d80
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x72cd4
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/ms_gauden.c |
enlarge_ntuple_list(ntuple_list_s*) | void enlarge_ntuple_list(ntuple_list n_tuple)
{
/* check parameters */
if ( n_tuple == NULL || n_tuple->values == NULL || n_tuple->max_size == 0 )
error("enlarge_ntuple_list: invalid n-tuple.");
/* duplicate number of tuples */
n_tuple->max_size *= 2;
/* realloc memory */
n_tuple->values = (double *) realloc( (void *) n_tuple->values,
n_tuple->dim * n_tuple->max_size * sizeof(double) );
if ( n_tuple->values == NULL ) error("not enough memory.");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6698
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6698
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x66a4
leaq 0x7ae6(%rip), %rdi # 0xe185
callq 0x6580
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x6060
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x66f6
leaq 0x7a81(%rip), %rdi # 0xe172
callq 0x6580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /soumyadeep94[P]Line-Segment-Detector-using-OpenCV/Detection/lsd.cpp |
new_image_char(unsigned int, unsigned int) | image_char new_image_char(unsigned int xsize, unsigned int ysize)
{
image_char image;
/* check parameters */
if ( xsize == 0 || ysize == 0 ) error("new_image_char: invalid image size.");
/* get memory */
image = (image_char) malloc( sizeof(struct image_char_s) );
if ( image == NULL ) error("not enough memory.");
image->data = (unsigned char *) calloc( (size_t) (xsize * ysize),
sizeof(unsigned char) );
if ( image->data == NULL ) error("not enough memory.");
/* set image size */
image->xsize = xsize;
image->ysize = ysize;
return image;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x68ba
cmpl $0x0, -0x8(%rbp)
jne 0x68c6
leaq 0x795e(%rip), %rdi # 0xe21f
callq 0x6580
movl $0x10, %edi
callq 0x61c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x68e7
leaq 0x7890(%rip), %rdi # 0xe172
callq 0x6580
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x61b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x691c
leaq 0x785b(%rip), %rdi # 0xe172
callq 0x6580
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /soumyadeep94[P]Line-Segment-Detector-using-OpenCV/Detection/lsd.cpp |
new_image_char_ini(unsigned int, unsigned int, unsigned char) | image_char new_image_char_ini( unsigned int xsize, unsigned int ysize,
unsigned char fill_value )
{
image_char image = new_image_char(xsize, ysize); /* create image */
unsigned int N = xsize * ysize;
unsigned int i;
/* check parameters */
if ( image == NULL || image->data == NULL )
error("new_image_char_ini: invalid image.");
/* initialize */
for (i = 0; i < N; i++) image->data[i] = fill_value;
return image;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x68a0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x697d
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6989
leaq 0x78bf(%rip), %rdi # 0xe243
callq 0x6580
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x69b3
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6990
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /soumyadeep94[P]Line-Segment-Detector-using-OpenCV/Detection/lsd.cpp |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
/* Also checks keybits */
if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
{
mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
(const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
#endif
SK = cty.rk + cty.nr * 4;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
{
for( j = 0; j < 4; j++, SK++ )
{
*RK++ = RT0[ FSb[ ( *SK ) & 0xFF ] ] ^
RT1[ FSb[ ( *SK >> 8 ) & 0xFF ] ] ^
RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
}
}
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
exit:
mbedtls_aes_free( &cty );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x30c0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x3d1f
movl %eax, %ebx
testl %eax, %eax
jne 0x452d
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x5828
testl %eax, %eax
je 0x4424
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %rsi
movl (%r14), %edx
callq 0x5a71
jmp 0x452d
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%r14)
movl 0x14(%rax), %ecx
movl %ecx, 0x14(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x18(%r14)
movl 0x1c(%rax), %ecx
leaq 0x20(%r14), %r15
movl %ecx, 0x1c(%r14)
movl (%r14), %ecx
cmpl $0x2, %ecx
jl 0x4513
leaq 0xccc4(%rip), %rdx # 0x11130
leaq 0xcdbd(%rip), %rsi # 0x11230
movl $0xff, %edi
leaq 0xd1b1(%rip), %r8 # 0x11630
leaq 0xd5aa(%rip), %r9 # 0x11a30
leaq 0xd9a3(%rip), %r11 # 0x11e30
movq %r15, %r10
xorl %r15d, %r15d
xorl %r14d, %r14d
movl (%rax,%r15,4), %r12d
movzbl %r12b, %r13d
movzbl (%r13,%rdx), %r13d
movl %r12d, %ebp
shrl $0x8, %ebp
andl %edi, %ebp
movzbl (%rbp,%rdx), %ebp
movl (%r8,%rbp,4), %ebp
xorl (%rsi,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x10, %r13d
andl %edi, %r13d
movzbl (%r13,%rdx), %r13d
xorl (%r9,%r13,4), %ebp
shrl $0x18, %r12d
movzbl (%r12,%rdx), %r12d
xorl (%r11,%r12,4), %ebp
movl %ebp, (%r10,%r15,4)
addq $-0x4, %r14
incq %r15
cmpl $0x4, %r15d
jne 0x4496
leal -0x1(%rcx), %ebp
movq %rax, %r12
subq %r14, %r12
leaq -0x20(%r12), %rax
movq %r10, %r15
subq %r14, %r15
cmpl $0x2, %ecx
movl %ebp, %ecx
jg 0x448d
addq $-0x20, %r12
subq %r14, %r10
movq %r10, %r15
movq %r12, %rax
movl (%rax), %ecx
movl %ecx, (%r15)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%r15)
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl 0xc(%rax), %eax
movl %eax, 0xc(%r15)
xorl %eax, %eax
movb $0x0, 0x8(%rsp,%rax)
incq %rax
cmpq $0x120, %rax # imm = 0x120
jne 0x452f
movl %ebx, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_encrypt | void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
xorl (%rsi), %ecx
xorl 0x4(%rsi), %r8d
movl 0x8(%rax), %r9d
xorl 0x8(%rsi), %r9d
movl 0xc(%rax), %edx
addq $0x10, %rax
xorl 0xc(%rsi), %edx
movl (%rdi), %esi
sarl %esi
leaq 0xdca1(%rip), %rbp # 0x12230
leaq 0xe09a(%rip), %r10 # 0x12630
cmpl $0x2, %esi
jl 0x4764
incl %esi
movl $0xff, %ebx
leaq 0xdc83(%rip), %rbp # 0x12230
leaq 0xe47c(%rip), %r15 # 0x12a30
movl %esi, -0x14(%rsp)
movl %ecx, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %r12d
xorl (%rax), %r12d
movl %r8d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r10,%rsi,4), %r12d
movl %r9d, %esi
shrl $0xe, %esi
movl $0x3fc, %edi # imm = 0x3FC
andl %edi, %esi
xorl (%rsi,%r15), %r12d
movl %edx, %esi
shrl $0x18, %esi
leaq 0xe843(%rip), %r14 # 0x12e30
xorl (%r14,%rsi,4), %r12d
movl %r8d, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %r13d
xorl 0x4(%rax), %r13d
movl %r9d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r10,%rsi,4), %r13d
movl %edx, %esi
shrl $0xe, %esi
andl %edi, %esi
movl $0x3fc, %r11d # imm = 0x3FC
xorl (%rsi,%r15), %r13d
movl %ecx, %esi
shrl $0x18, %esi
xorl (%r14,%rsi,4), %r13d
movl %r9d, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %esi
xorl 0x8(%rax), %esi
movq %r10, %rdi
movl %edx, %r10d
shrl $0x8, %r10d
andl %ebx, %r10d
xorl (%rdi,%r10,4), %esi
movl %ecx, %r10d
shrl $0xe, %r10d
andl %r11d, %r10d
xorl (%r10,%r15), %esi
movl %r8d, %r10d
shrl $0x18, %r10d
xorl (%r14,%r10,4), %esi
andl %ebx, %edx
movl (%rbp,%rdx,4), %r10d
xorl 0xc(%rax), %r10d
shrl $0x8, %ecx
andl %ebx, %ecx
xorl (%rdi,%rcx,4), %r10d
shrl $0xe, %r8d
andl %r11d, %r8d
xorl (%r8,%r15), %r10d
shrl $0x18, %r9d
movq %r14, %r11
xorl (%r14,%r9,4), %r10d
movl %r12d, %ecx
andl %ebx, %ecx
movl (%rbp,%rcx,4), %ecx
xorl 0x10(%rax), %ecx
movl %r13d, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %ecx
movl %esi, %edx
shrl $0xe, %edx
movl $0x3fc, %r9d # imm = 0x3FC
andl %r9d, %edx
xorl (%rdx,%r15), %ecx
movl %r10d, %edx
shrl $0x18, %edx
xorl (%r14,%rdx,4), %ecx
movl %r13d, %edx
andl %ebx, %edx
movl (%rbp,%rdx,4), %r8d
xorl 0x14(%rax), %r8d
movl %esi, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %r8d
movl %r10d, %edx
shrl $0xe, %edx
andl %r9d, %edx
xorl (%rdx,%r15), %r8d
movl %r12d, %edx
shrl $0x18, %edx
xorl (%r14,%rdx,4), %r8d
movl %esi, %edx
andl %ebx, %edx
movl (%rbp,%rdx,4), %r9d
xorl 0x18(%rax), %r9d
movl %r10d, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %r9d
movl %r12d, %edx
shrl $0xe, %edx
movl $0x3fc, %r14d # imm = 0x3FC
andl %r14d, %edx
xorl (%rdx,%r15), %r9d
movl %r13d, %edx
shrl $0x18, %edx
xorl (%r11,%rdx,4), %r9d
andl %ebx, %r10d
movl (%rbp,%r10,4), %edx
movq %rdi, %r10
xorl 0x1c(%rax), %edx
shrl $0x8, %r12d
andl %ebx, %r12d
xorl (%rdi,%r12,4), %edx
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%r15), %edx
shrl $0x18, %esi
xorl (%r11,%rsi,4), %edx
movl -0x14(%rsp), %esi
addq $0x20, %rax
decl %esi
cmpl $0x2, %esi
ja 0x45b4
leaq 0xdacc(%rip), %rbp # 0x12230
movl $0xff, %ebx
movl %ecx, %esi
andl %ebx, %esi
movl (%rbp,%rsi,4), %r12d
xorl (%rax), %r12d
movl %r8d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r10,%rsi,4), %r12d
movq %r10, %rdi
movl %r9d, %r10d
shrl $0xe, %r10d
movl $0x3fc, %esi # imm = 0x3FC
andl %esi, %r10d
leaq 0xe296(%rip), %r14 # 0x12a30
xorl (%r10,%r14), %r12d
movl %edx, %r10d
shrl $0x18, %r10d
leaq 0xe684(%rip), %r13 # 0x12e30
xorl (%r13,%r10,4), %r12d
movl %r8d, %r10d
andl %ebx, %r10d
movl (%rbp,%r10,4), %r11d
xorl 0x4(%rax), %r11d
movl %r9d, %r10d
shrl $0x8, %r10d
andl %ebx, %r10d
xorl (%rdi,%r10,4), %r11d
movl %edx, %r10d
shrl $0xe, %r10d
andl %esi, %r10d
xorl (%r10,%r14), %r11d
movl %ecx, %r10d
shrl $0x18, %r10d
xorl (%r13,%r10,4), %r11d
movl %r9d, %r10d
andl %ebx, %r10d
movl (%rbp,%r10,4), %r15d
xorl 0x8(%rax), %r15d
movl %edx, %r10d
shrl $0x8, %r10d
andl %ebx, %r10d
xorl (%rdi,%r10,4), %r15d
movl %ecx, %r10d
shrl $0xe, %r10d
andl %esi, %r10d
xorl (%r10,%r14), %r15d
movl %r8d, %r10d
shrl $0x18, %r10d
xorl (%r13,%r10,4), %r15d
andl %ebx, %edx
movl (%rbp,%rdx,4), %r10d
xorl 0xc(%rax), %r10d
shrl $0x8, %ecx
andl %ebx, %ecx
xorl (%rdi,%rcx,4), %r10d
shrl $0xe, %r8d
andl %esi, %r8d
xorl (%r8,%r14), %r10d
shrl $0x18, %r9d
xorl (%r13,%r9,4), %r10d
movl %r12d, %ecx
andl %ebx, %ecx
leaq 0xc8dd(%rip), %rdi # 0x11130
movzbl (%rcx,%rdi), %ecx
xorl 0x10(%rax), %ecx
movl %ecx, %r8d
movl %ecx, -0x10(%rsp)
movl %r11d, %ecx
shrl $0x8, %ecx
andl %ebx, %ecx
movzbl (%rcx,%rdi), %ecx
shll $0x8, %ecx
movl %r15d, %esi
shrl $0x10, %esi
andl %ebx, %esi
movzbl (%rsi,%rdi), %esi
shll $0x10, %esi
orl %ecx, %esi
movl %r10d, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%rdi), %ecx
shll $0x18, %ecx
orl %esi, %ecx
movl %r11d, %esi
andl %ebx, %esi
movzbl (%rsi,%rdi), %edx
xorl 0x14(%rax), %edx
movl %edx, -0x14(%rsp)
movl %r15d, %edx
shrl $0x8, %edx
andl %ebx, %edx
movl %r10d, %r13d
shrl $0x10, %r13d
movl %r15d, %esi
andl %ebx, %esi
movzbl (%rsi,%rdi), %esi
xorl 0x18(%rax), %esi
movl %esi, -0xc(%rsp)
andl %ebx, %r13d
movl %r10d, %ebp
shrl $0x8, %ebp
andl %ebx, %ebp
andl %ebx, %r10d
movzbl (%r10,%rdi), %r9d
xorl 0x1c(%rax), %r9d
movl %r12d, %r10d
shrl $0x10, %r10d
andl %ebx, %r10d
movl %r12d, %eax
shrl $0x8, %r12d
andl %ebx, %r12d
movl %r11d, %r14d
shrl $0x10, %r11d
andl %ebx, %r11d
xorl %r8d, %ecx
movzbl (%rdx,%rdi), %esi
movzbl (%r13,%rdi), %r13d
shrl $0x18, %eax
movzbl (%rax,%rdi), %eax
movzbl (%rbp,%rdi), %r8d
movzbl (%r10,%rdi), %ebp
shrl $0x18, %r14d
movzbl (%r14,%rdi), %ebx
movzbl (%r12,%rdi), %r10d
movzbl (%r11,%rdi), %r11d
shrl $0x18, %r15d
movzbl (%r15,%rdi), %r14d
movq -0x8(%rsp), %rdx
movl -0x10(%rsp), %edi
movb %dil, (%rdx)
movb %ch, 0x1(%rdx)
movl %ecx, %edi
shrl $0x10, %edi
movb %dil, 0x2(%rdx)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx)
shll $0x8, %esi
shll $0x10, %r13d
orl %esi, %r13d
shll $0x18, %eax
orl %r13d, %eax
movl -0x14(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0x4(%rdx)
movb %ah, 0x5(%rdx)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rdx)
shrl $0x18, %eax
movb %al, 0x7(%rdx)
shll $0x8, %r8d
shll $0x10, %ebp
orl %r8d, %ebp
shll $0x18, %ebx
orl %ebp, %ebx
movl -0xc(%rsp), %eax
xorl %eax, %ebx
movb %al, 0x8(%rdx)
movb %bh, 0x9(%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rdx)
shrl $0x18, %ebx
movb %bl, 0xb(%rdx)
shll $0x8, %r10d
shll $0x10, %r11d
orl %r10d, %r11d
movl %r14d, %ecx
shll $0x18, %ecx
orl %r11d, %ecx
xorl %r9d, %ecx
movb %r9b, 0xc(%rdx)
movb %ch, 0xd(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rdx)
shrl $0x18, %ecx
movb %cl, 0xf(%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_decrypt | void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %edx
xorl (%rsi), %ecx
xorl 0x4(%rsi), %edx
movl 0x8(%rax), %r9d
xorl 0x8(%rsi), %r9d
movl 0xc(%rax), %r10d
addq $0x10, %rax
xorl 0xc(%rsi), %r10d
movl (%rdi), %esi
sarl %esi
leaq 0xc81d(%rip), %rdi # 0x11230
leaq 0xcc16(%rip), %r8 # 0x11630
cmpl $0x2, %esi
jl 0x4bee
incl %esi
movl $0xff, %ebx
leaq 0xcfff(%rip), %r15 # 0x11a30
movl %esi, -0x14(%rsp)
movl %ecx, %esi
andl %ebx, %esi
movl (%rdi,%rsi,4), %r12d
xorl (%rax), %r12d
movl %r10d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r8,%rsi,4), %r12d
movl %r9d, %esi
shrl $0xe, %esi
movl $0x3fc, %ebp # imm = 0x3FC
andl %ebp, %esi
movl $0x3fc, %r11d # imm = 0x3FC
xorl (%rsi,%r15), %r12d
movl %edx, %esi
shrl $0x18, %esi
leaq 0xd3c1(%rip), %r14 # 0x11e30
xorl (%r14,%rsi,4), %r12d
movl %edx, %esi
andl %ebx, %esi
movl (%rdi,%rsi,4), %r13d
xorl 0x4(%rax), %r13d
movl %ecx, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r8,%rsi,4), %r13d
movl %r10d, %esi
shrl $0xe, %esi
andl %r11d, %esi
xorl (%rsi,%r15), %r13d
movl %r9d, %esi
shrl $0x18, %esi
xorl (%r14,%rsi,4), %r13d
movl %r9d, %esi
andl %ebx, %esi
movl (%rdi,%rsi,4), %esi
xorl 0x8(%rax), %esi
movq %rdi, %rbp
movq %r8, %rdi
movl %edx, %r8d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%rdi,%r8,4), %esi
movl %ecx, %r8d
shrl $0xe, %r8d
andl %r11d, %r8d
xorl (%r8,%r15), %esi
movl %r10d, %r8d
shrl $0x18, %r8d
xorl (%r14,%r8,4), %esi
movq %r14, %r11
andl %ebx, %r10d
movl (%rbp,%r10,4), %r10d
xorl 0xc(%rax), %r10d
shrl $0x8, %r9d
andl %ebx, %r9d
xorl (%rdi,%r9,4), %r10d
shrl $0xe, %edx
movl $0x3fc, %r8d # imm = 0x3FC
andl %r8d, %edx
xorl (%rdx,%r15), %r10d
shrl $0x18, %ecx
xorl (%r14,%rcx,4), %r10d
movl %r12d, %ecx
andl %ebx, %ecx
movl (%rbp,%rcx,4), %ecx
xorl 0x10(%rax), %ecx
movl %r10d, %edx
shrl $0x8, %edx
andl %ebx, %edx
xorl (%rdi,%rdx,4), %ecx
movl %esi, %edx
shrl $0xe, %edx
andl %r8d, %edx
movl $0x3fc, %r9d # imm = 0x3FC
xorl (%rdx,%r15), %ecx
movl %r13d, %edx
shrl $0x18, %edx
xorl (%r14,%rdx,4), %ecx
movl %r13d, %edx
andl %ebx, %edx
movl (%rbp,%rdx,4), %edx
xorl 0x14(%rax), %edx
movl %r12d, %r8d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%rdi,%r8,4), %edx
movl %r10d, %r8d
shrl $0xe, %r8d
andl %r9d, %r8d
xorl (%r8,%r15), %edx
movl %esi, %r8d
shrl $0x18, %r8d
xorl (%r14,%r8,4), %edx
movl %esi, %r8d
andl %ebx, %r8d
movl (%rbp,%r8,4), %r9d
xorl 0x18(%rax), %r9d
movl %r13d, %r8d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%rdi,%r8,4), %r9d
movl %r12d, %r8d
shrl $0xe, %r8d
movl $0x3fc, %r14d # imm = 0x3FC
andl %r14d, %r8d
xorl (%r8,%r15), %r9d
movl %r10d, %r8d
shrl $0x18, %r8d
xorl (%r11,%r8,4), %r9d
movq %rdi, %r8
movq %rbp, %rdi
andl %ebx, %r10d
movl (%rbp,%r10,4), %r10d
xorl 0x1c(%rax), %r10d
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r8,%rsi,4), %r10d
movl -0x14(%rsp), %esi
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%r15), %r10d
shrl $0x18, %r12d
xorl (%r11,%r12,4), %r10d
addq $0x20, %rax
decl %esi
cmpl $0x2, %esi
ja 0x4a31
movl $0xff, %ebx
movl %ecx, %esi
andl %ebx, %esi
movl (%rdi,%rsi,4), %ebp
xorl (%rax), %ebp
movl %r10d, %esi
shrl $0x8, %esi
andl %ebx, %esi
xorl (%r8,%rsi,4), %ebp
movq %rdi, %r15
movq %r8, %rdi
movl %r9d, %r8d
shrl $0xe, %r8d
movl $0x3fc, %r11d # imm = 0x3FC
andl %r11d, %r8d
leaq 0xce0b(%rip), %r12 # 0x11a30
xorl (%r8,%r12), %ebp
movl %edx, %r8d
shrl $0x18, %r8d
leaq 0xd1f9(%rip), %r13 # 0x11e30
xorl (%r13,%r8,4), %ebp
movl %edx, %r8d
andl %ebx, %r8d
movl (%r15,%r8,4), %r14d
xorl 0x4(%rax), %r14d
movl %ecx, %r8d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%rdi,%r8,4), %r14d
movl %r10d, %r8d
shrl $0xe, %r8d
andl %r11d, %r8d
xorl (%r8,%r12), %r14d
movl %r9d, %r8d
shrl $0x18, %r8d
xorl (%r13,%r8,4), %r14d
movl %r9d, %r8d
andl %ebx, %r8d
movl (%r15,%r8,4), %esi
xorl 0x8(%rax), %esi
movl %edx, %r8d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%rdi,%r8,4), %esi
movl %ecx, %r8d
shrl $0xe, %r8d
andl %r11d, %r8d
xorl (%r8,%r12), %esi
movl %r10d, %r8d
shrl $0x18, %r8d
xorl (%r13,%r8,4), %esi
andl %ebx, %r10d
movl (%r15,%r10,4), %r10d
xorl 0xc(%rax), %r10d
shrl $0x8, %r9d
andl %ebx, %r9d
xorl (%rdi,%r9,4), %r10d
shrl $0xe, %edx
andl %r11d, %edx
xorl (%rdx,%r12), %r10d
shrl $0x18, %ecx
xorl (%r13,%rcx,4), %r10d
movl %ebp, %ecx
andl %ebx, %ecx
leaq 0xe556(%rip), %r8 # 0x13230
movzbl (%rcx,%r8), %ecx
xorl 0x10(%rax), %ecx
movl %ecx, %edi
movl %r10d, %ecx
shrl $0x8, %ecx
andl %ebx, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x8, %ecx
movl %esi, %edx
shrl $0x10, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
shll $0x10, %edx
orl %ecx, %edx
movl %r14d, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x18, %ecx
orl %edx, %ecx
movl %r14d, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
xorl 0x14(%rax), %edx
movl %edx, -0x14(%rsp)
movl %ebp, %r12d
shrl $0x8, %r12d
andl %ebx, %r12d
movl %r10d, %r13d
shrl $0x10, %r13d
movl %esi, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
xorl 0x18(%rax), %edx
movl %edx, -0xc(%rsp)
andl %ebx, %r13d
movl %r10d, %edx
andl %ebx, %r10d
movzbl (%r10,%r8), %r9d
xorl 0x1c(%rax), %r9d
movl %r9d, -0x10(%rsp)
movl %r14d, %eax
shrl $0x8, %eax
andl %ebx, %eax
movl %ebp, %r11d
shrl $0x10, %r11d
andl %ebx, %r11d
movl %esi, %r15d
shrl $0x8, %esi
andl %ebx, %esi
shrl $0x10, %r14d
andl %ebx, %r14d
xorl %edi, %ecx
movl %edi, %r9d
movzbl (%r12,%r8), %edi
movzbl (%r13,%r8), %r10d
shrl $0x18, %r15d
movzbl (%r15,%r8), %ebx
movzbl (%rax,%r8), %r13d
movzbl (%r11,%r8), %r12d
shrl $0x18, %edx
movzbl (%rdx,%r8), %edx
movzbl (%rsi,%r8), %r15d
movzbl (%r14,%r8), %r14d
shrl $0x18, %ebp
movzbl (%rbp,%r8), %eax
movq -0x8(%rsp), %rbp
movb %r9b, (%rbp)
movb %ch, 0x1(%rbp)
movl %ecx, %esi
shrl $0x10, %esi
movb %sil, 0x2(%rbp)
shrl $0x18, %ecx
movb %cl, 0x3(%rbp)
shll $0x8, %edi
shll $0x10, %r10d
orl %edi, %r10d
shll $0x18, %ebx
orl %r10d, %ebx
movl -0x14(%rsp), %ecx
xorl %ecx, %ebx
movb %cl, 0x4(%rbp)
movb %bh, 0x5(%rbp)
movl %ebx, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rbp)
shrl $0x18, %ebx
movb %bl, 0x7(%rbp)
shll $0x8, %r13d
shll $0x10, %r12d
orl %r13d, %r12d
shll $0x18, %edx
orl %r12d, %edx
movl -0xc(%rsp), %ecx
xorl %ecx, %edx
movb %cl, 0x8(%rbp)
movb %dh, 0x9(%rbp)
movl %edx, %ecx
shrl $0x10, %ecx
movb %cl, 0xa(%rbp)
shrl $0x18, %edx
movb %dl, 0xb(%rbp)
shll $0x8, %r15d
shll $0x10, %r14d
orl %r15d, %r14d
shll $0x18, %eax
orl %r14d, %eax
movl -0x10(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0xc(%rbp)
movb %ah, 0xd(%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0xe(%rbp)
shrl $0x18, %eax
movb %al, 0xf(%rbp)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_sha1 | void mbedtls_sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
{
mbedtls_sha1_context ctx;
mbedtls_sha1_init( &ctx );
mbedtls_sha1_starts( &ctx );
mbedtls_sha1_update( &ctx, input, ilen );
mbedtls_sha1_finish( &ctx, output );
mbedtls_sha1_free( &ctx );
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movups %xmm0, 0x4c(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps 0x34bd(%rip), %xmm0 # 0xc6c0
movups %xmm0, 0x8(%r14)
movl $0xc3d2e1f0, 0x18(%r14) # imm = 0xC3D2E1F0
movq %r14, %rdi
callq 0x8fef
movq %r14, %rdi
movq %rbx, %rsi
callq 0x90a9
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x5c, %rax
jne 0x9225
addq $0x68, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_sha256_process | void mbedtls_sha256_process( mbedtls_sha256_context *ctx, const unsigned char data[64] )
{
uint32_t temp1, temp2, W[64];
uint32_t A[8];
unsigned int i;
for( i = 0; i < 8; i++ )
A[i] = ctx->state[i];
#if defined(MBEDTLS_SHA256_SMALLER)
for( i = 0; i < 64; i++ )
{
if( i < 16 )
GET_UINT32_BE( W[i], data, 4 * i );
else
R( i );
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] );
temp1 = A[7]; A[7] = A[6]; A[6] = A[5]; A[5] = A[4]; A[4] = A[3];
A[3] = A[2]; A[2] = A[1]; A[1] = A[0]; A[0] = temp1;
}
#else /* MBEDTLS_SHA256_SMALLER */
for( i = 0; i < 16; i++ )
GET_UINT32_BE( W[i], data, 4 * i );
for( i = 0; i < 16; i += 8 )
{
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i+0], K[i+0] );
P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i+1], K[i+1] );
P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i+2], K[i+2] );
P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i+3], K[i+3] );
P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i+4], K[i+4] );
P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i+5], K[i+5] );
P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i+6], K[i+6] );
P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i+7], K[i+7] );
}
for( i = 16; i < 64; i += 8 )
{
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], R(i+0), K[i+0] );
P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], R(i+1), K[i+1] );
P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], R(i+2), K[i+2] );
P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], R(i+3), K[i+3] );
P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], R(i+4), K[i+4] );
P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], R(i+5), K[i+5] );
P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], R(i+6), K[i+6] );
P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], R(i+7), K[i+7] );
}
#endif /* MBEDTLS_SHA256_SMALLER */
for( i = 0; i < 8; i++ )
ctx->state[i] += A[i];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rdi), %rax
movq %rax, -0x48(%rsp)
movdqu 0x8(%rdi), %xmm0
movups 0x18(%rdi), %xmm1
movaps %xmm1, -0x60(%rsp)
movdqa %xmm0, -0x70(%rsp)
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
bswapl %ecx
movl %ecx, -0x40(%rsp,%rax,4)
incq %rax
cmpq $0x10, %rax
jne 0x9479
movl -0x54(%rsp), %ebx
movl -0x60(%rsp), %r14d
movl -0x58(%rsp), %r11d
movl -0x5c(%rsp), %edx
movl -0x70(%rsp), %ebp
movl -0x6c(%rsp), %r10d
movl -0x68(%rsp), %r8d
leaq -0x40(%rsp), %rax
movb $0x1, %cl
movl -0x64(%rsp), %edi
xorl %r15d, %r15d
movl %ecx, -0x7c(%rsp)
movl %r14d, %r13d
roll $0x1a, %r13d
movl %r14d, %ecx
roll $0x15, %ecx
movl %r14d, %esi
roll $0x7, %esi
movl %edx, %r12d
xorl %r11d, %r12d
andl %r14d, %r12d
movl %ebp, %r9d
roll $0x1e, %r9d
xorl %r13d, %ecx
movl %ebp, %r13d
roll $0x13, %r13d
xorl %ecx, %esi
xorl %r11d, %r12d
xorl %r9d, %r13d
movl %ebp, %ecx
addl %ebx, %esi
roll $0xa, %ecx
leaq 0x3570(%rip), %r9 # 0xca70
addl (%r9,%r15,4), %esi
xorl %r13d, %ecx
movl %r10d, %r9d
addl (%rax), %esi
andl %ebp, %r9d
movl %r10d, %ebx
orl %ebp, %ebx
addl %r12d, %esi
andl %r8d, %ebx
orl %r9d, %ebx
addl %ecx, %ebx
addl %esi, %edi
addl %esi, %ebx
movl %edi, %r13d
roll $0x1a, %r13d
movl %edi, %r12d
movl %edi, %esi
roll $0x15, %r12d
movl %edx, %eax
xorl %r14d, %eax
roll $0x7, %esi
andl %edi, %eax
xorl %edx, %eax
movl %ebx, %ecx
addl %r11d, %eax
roll $0x1e, %ecx
leaq 0x3522(%rip), %r9 # 0xca70
addl 0x4(%r9,%r15,4), %eax
movl %ebx, %r9d
roll $0x13, %r9d
xorl %r13d, %r12d
movl %ebx, %r13d
roll $0xa, %r13d
xorl %r12d, %esi
xorl %ecx, %r9d
movl %ebx, %ecx
andl %ebp, %ecx
xorl %r9d, %r13d
movl %ebx, %r11d
orl %ebp, %r11d
andl %r10d, %r11d
addl %esi, %eax
orl %ecx, %r11d
addl %r13d, %r11d
addl -0x3c(%rsp,%r15,4), %eax
addl %eax, %r8d
addl %eax, %r11d
movl %r8d, %ecx
movl %r8d, %esi
movl %r8d, %eax
movl %edi, %r9d
roll $0x1a, %ecx
xorl %r14d, %r9d
andl %r8d, %r9d
roll $0x15, %esi
leaq 0x34c4(%rip), %r12 # 0xca70
addl 0x8(%r12,%r15,4), %edx
roll $0x7, %eax
xorl %r14d, %r9d
addl -0x38(%rsp,%r15,4), %edx
addl %r9d, %edx
movl %r11d, %r9d
roll $0x1e, %r9d
xorl %ecx, %esi
movl %r11d, %ecx
roll $0x13, %ecx
xorl %r9d, %ecx
movl %r11d, %r9d
roll $0xa, %r9d
xorl %esi, %eax
movl %r11d, %esi
andl %ebx, %esi
movl %r11d, %r12d
xorl %ecx, %r9d
orl %ebx, %r12d
andl %ebp, %r12d
orl %esi, %r12d
addl %eax, %edx
addl %r9d, %r12d
addl %edx, %r10d
addl %r12d, %edx
movl %r10d, %r12d
movl %r10d, %esi
movl %r10d, %eax
roll $0x1a, %r12d
movl %r8d, %ecx
xorl %edi, %ecx
roll $0x15, %esi
leaq 0x345b(%rip), %r9 # 0xca70
addl 0xc(%r9,%r15,4), %r14d
roll $0x7, %eax
andl %r10d, %ecx
addl -0x34(%rsp,%r15,4), %r14d
xorl %edi, %ecx
movl %edx, %r9d
roll $0x1e, %r9d
addl %ecx, %r14d
movl %edx, %ecx
roll $0x13, %ecx
xorl %r12d, %esi
movl %edx, %r12d
roll $0xa, %r12d
xorl %esi, %eax
xorl %r9d, %ecx
movl %edx, %esi
andl %r11d, %esi
xorl %ecx, %r12d
movl %edx, %ecx
orl %r11d, %ecx
andl %ebx, %ecx
addl %eax, %r14d
orl %esi, %ecx
addl %r12d, %ecx
addl %r14d, %ebp
addl %ecx, %r14d
movl %ebp, %ecx
movl %ebp, %eax
movl %r10d, %r9d
movl %ebp, %esi
xorl %r8d, %r9d
andl %ebp, %r9d
roll $0x1a, %ecx
leaq 0x33f5(%rip), %r12 # 0xca70
addl 0x10(%r12,%r15,4), %edi
roll $0x15, %eax
addl -0x30(%rsp,%r15,4), %edi
roll $0x7, %esi
xorl %r8d, %r9d
addl %r9d, %edi
movl %r14d, %r9d
xorl %ecx, %eax
roll $0x1e, %r9d
movl %r14d, %ecx
movl %edi, %r12d
roll $0x13, %ecx
xorl %r9d, %ecx
xorl %eax, %esi
movl %r14d, %eax
roll $0xa, %eax
xorl %ecx, %eax
movl %r14d, %ecx
andl %edx, %ecx
movl %r14d, %edi
addl %esi, %r12d
orl %edx, %edi
andl %r11d, %edi
orl %ecx, %edi
addl %eax, %edi
addl %r12d, %ebx
movl %ebx, %ecx
movl %ebx, %eax
addl %r12d, %edi
movl %ebx, %esi
movl %ebp, %r9d
roll $0x1a, %ecx
xorl %r10d, %r9d
andl %ebx, %r9d
roll $0x15, %eax
leaq 0x338a(%rip), %r12 # 0xca70
addl 0x14(%r12,%r15,4), %r8d
roll $0x7, %esi
xorl %r10d, %r9d
addl -0x2c(%rsp,%r15,4), %r8d
xorl %ecx, %eax
addl %r9d, %r8d
movl %edi, %ecx
roll $0x1e, %ecx
movl %r8d, %r9d
movl %edi, %r12d
roll $0x13, %r12d
movl %edi, %r13d
roll $0xa, %r13d
xorl %eax, %esi
addl %esi, %r9d
movl %edi, %eax
andl %r14d, %eax
xorl %ecx, %r12d
movl %edi, %r8d
orl %r14d, %r8d
andl %edx, %r8d
xorl %r12d, %r13d
orl %eax, %r8d
addl %r13d, %r8d
leaq 0x3339(%rip), %r12 # 0xca70
addl %r9d, %r11d
addl %r9d, %r8d
movl %r11d, %eax
movl %r11d, %ecx
roll $0x1a, %eax
movl %r11d, %r9d
movl %ebx, %esi
roll $0x15, %ecx
xorl %ebp, %esi
andl %r11d, %esi
roll $0x7, %r9d
xorl %ebp, %esi
addl 0x18(%r12,%r15,4), %r10d
xorl %eax, %ecx
addl -0x28(%rsp,%r15,4), %r10d
addl %esi, %r10d
movl %r10d, %esi
movl %r8d, %eax
roll $0x1e, %eax
xorl %ecx, %r9d
movl %r8d, %ecx
roll $0x13, %ecx
addl %r9d, %esi
movl %r8d, %r9d
roll $0xa, %r9d
xorl %eax, %ecx
movl %r8d, %eax
andl %edi, %eax
movl %r8d, %r10d
xorl %ecx, %r9d
orl %edi, %r10d
andl %r14d, %r10d
orl %eax, %r10d
addl %r9d, %r10d
addl %esi, %edx
movl %edx, %ecx
movl %edx, %eax
addl %esi, %r10d
movl %edx, %esi
movl %r11d, %r9d
roll $0x1a, %ecx
xorl %ebx, %r9d
andl %edx, %r9d
roll $0x15, %eax
addl 0x1c(%r12,%r15,4), %ebp
roll $0x7, %esi
xorl %ebx, %r9d
addl -0x24(%rsp,%r15,4), %ebp
xorl %ecx, %eax
addl %r9d, %ebp
movl %r10d, %ecx
roll $0x1e, %ecx
movl %ebp, %r9d
movl %r10d, %r15d
roll $0x13, %r15d
movl %r10d, %r12d
roll $0xa, %r12d
xorl %eax, %esi
addl %esi, %r9d
movl %r10d, %eax
andl %r8d, %eax
xorl %ecx, %r15d
movl %r10d, %ebp
orl %r8d, %ebp
andl %edi, %ebp
xorl %r15d, %r12d
orl %eax, %ebp
addl %r12d, %ebp
addl %r9d, %r14d
addl %r9d, %ebp
leaq -0x20(%rsp), %rax
movl $0x8, %r15d
testb $0x1, -0x7c(%rsp)
movl $0x0, %ecx
jne 0x94b9
movl $0x10, %ecx
movl -0x40(%rsp), %eax
movl %r14d, %r9d
roll $0x1a, %r9d
movl %r14d, %r15d
roll $0x15, %r15d
movl %r14d, %esi
roll $0x7, %esi
xorl %r9d, %r15d
xorl %r15d, %esi
addl %ebx, %esi
movl %edx, %ebx
xorl %r11d, %ebx
andl %r14d, %ebx
xorl %r11d, %ebx
movl -0x48(%rsp,%rcx,4), %r12d
movl %r12d, %r9d
roll $0xf, %r9d
movl %r12d, %r15d
roll $0xd, %r15d
xorl %r9d, %r15d
shrl $0xa, %r12d
xorl %r15d, %r12d
addl -0x5c(%rsp,%rcx,4), %r12d
movl -0x7c(%rsp,%rcx,4), %r15d
movl -0x78(%rsp,%rcx,4), %r9d
movl %r9d, -0x78(%rsp)
movq %rcx, %r9
movl %r15d, %ecx
movl %r15d, -0x7c(%rsp)
movl %r15d, %r13d
roll $0x19, %r13d
roll $0xe, %r15d
xorl %r13d, %r15d
movl %ecx, %r13d
shrl $0x3, %r13d
xorl %r15d, %r13d
addl %eax, %r13d
addl %r12d, %r13d
movl %r13d, -0x40(%rsp,%r9,4)
movl %r13d, -0x74(%rsp)
leaq 0x31b3(%rip), %rax # 0xca70
addl (%rax,%r9,4), %esi
movq %r9, -0x50(%rsp)
addl %ebx, %esi
movl %ebp, %eax
roll $0x1e, %eax
addl %r13d, %esi
movl %ebp, %ebx
roll $0x13, %ebx
xorl %eax, %ebx
movl %ebp, %eax
roll $0xa, %eax
xorl %ebx, %eax
movl %r10d, %r15d
andl %ebp, %r15d
movl %r10d, %ebx
orl %ebp, %ebx
andl %r8d, %ebx
orl %r15d, %ebx
addl %eax, %ebx
addl %esi, %edi
movl %edi, %eax
roll $0x1a, %eax
addl %esi, %ebx
movl %edi, %r15d
roll $0x15, %r15d
xorl %eax, %r15d
movl %edi, %eax
roll $0x7, %eax
movl -0x44(%rsp,%r9,4), %esi
movl %esi, %r12d
roll $0xf, %r12d
xorl %r15d, %eax
movl %esi, %r15d
roll $0xd, %r15d
xorl %r12d, %r15d
shrl $0xa, %esi
xorl %r15d, %esi
movl -0x78(%rsp), %r9d
movl %r9d, %r13d
movl -0x74(%rsp), %r15d
movl %r15d, %ecx
roll $0xf, %ecx
movl %r15d, %r12d
roll $0xd, %r12d
xorl %ecx, %r12d
movl %r15d, %ecx
shrl $0xa, %ecx
xorl %r12d, %ecx
addl %r9d, %ecx
movl %r9d, %r12d
roll $0x19, %r12d
roll $0xe, %r13d
xorl %r12d, %r13d
movl %edx, %r12d
xorl %r14d, %r12d
andl %edi, %r12d
xorl %edx, %r12d
shrl $0x3, %r9d
xorl %r13d, %r9d
movl -0x7c(%rsp), %r15d
movq -0x50(%rsp), %r13
addl -0x58(%rsp,%r13,4), %r15d
addl %esi, %r15d
addl %r9d, %r15d
movl %r15d, -0x3c(%rsp,%r13,4)
addl %r11d, %r12d
leaq 0x30da(%rip), %rsi # 0xca70
addl 0x4(%rsi,%r13,4), %r12d
addl %r15d, %eax
movl %ebx, %esi
roll $0x1e, %esi
addl %r12d, %eax
movl %ebx, %r9d
roll $0x13, %r9d
xorl %esi, %r9d
movl %ebx, %esi
roll $0xa, %esi
xorl %r9d, %esi
movl %ebx, %r9d
andl %ebp, %r9d
movl %ebx, %r11d
orl %ebp, %r11d
andl %r10d, %r11d
orl %r9d, %r11d
addl %esi, %r11d
addl %eax, %r8d
movl %r8d, %esi
roll $0x1a, %esi
addl %eax, %r11d
movl %r8d, %r9d
roll $0x15, %r9d
xorl %esi, %r9d
movl %r8d, %eax
roll $0x7, %eax
xorl %r9d, %eax
movl %edi, %esi
xorl %r14d, %esi
andl %r8d, %esi
movl -0x74(%rsp,%r13,4), %r9d
movl %r15d, %r12d
roll $0xf, %r12d
movl %r15d, %r13d
roll $0xd, %r13d
xorl %r12d, %r13d
movl %r9d, %r12d
shrl $0xa, %r15d
xorl %r13d, %r15d
movl %r9d, %r13d
addl %r9d, %r15d
roll $0x19, %r9d
xorl %r14d, %esi
roll $0xe, %r12d
xorl %r9d, %r12d
shrl $0x3, %r13d
xorl %r12d, %r13d
movq -0x50(%rsp), %r12
addl -0x54(%rsp,%r12,4), %ecx
addl %r13d, %ecx
movl %ecx, -0x38(%rsp,%r12,4)
leaq 0x3028(%rip), %r9 # 0xca70
addl 0x8(%r9,%r12,4), %edx
movq %r12, %r13
addl %esi, %edx
movl %r11d, %esi
roll $0x1e, %esi
addl %ecx, %edx
movl %r11d, %r9d
roll $0x13, %r9d
addl %eax, %edx
movl %r11d, %eax
roll $0xa, %eax
xorl %esi, %r9d
xorl %r9d, %eax
movl %r11d, %esi
andl %ebx, %esi
movl %r11d, %r9d
orl %ebx, %r9d
andl %ebp, %r9d
orl %esi, %r9d
addl %edx, %r10d
movl %r10d, %esi
roll $0x1a, %esi
addl %eax, %r9d
movl %r10d, %r12d
roll $0x15, %r12d
addl %r9d, %edx
movl %r10d, %eax
roll $0x7, %eax
xorl %esi, %r12d
xorl %r12d, %eax
movl %eax, -0x7c(%rsp)
movl %r8d, %esi
xorl %edi, %esi
andl %r10d, %esi
movl %ecx, %r9d
roll $0xf, %r9d
xorl %edi, %esi
movl %ecx, %r12d
roll $0xd, %r12d
movq %r13, %rax
movl -0x70(%rsp,%r13,4), %r13d
xorl %r9d, %r12d
movl %r13d, %r9d
shrl $0xa, %ecx
xorl %r12d, %ecx
movl %r13d, %r12d
addl %r13d, %ecx
roll $0x19, %r13d
roll $0xe, %r9d
xorl %r13d, %r9d
shrl $0x3, %r12d
addl -0x50(%rsp,%rax,4), %r15d
xorl %r9d, %r12d
addl %r12d, %r15d
leaq 0x2f77(%rip), %r9 # 0xca70
addl 0xc(%r9,%rax,4), %r14d
movl %r15d, -0x34(%rsp,%rax,4)
movq %rax, %r13
addl %r15d, %r14d
addl %esi, %r14d
addl -0x7c(%rsp), %r14d
movl %edx, %eax
roll $0x1e, %eax
movl %edx, %esi
roll $0x13, %esi
xorl %eax, %esi
movl %edx, %eax
roll $0xa, %eax
xorl %esi, %eax
movl %edx, %esi
andl %r11d, %esi
movl %edx, %r9d
orl %r11d, %r9d
andl %ebx, %r9d
orl %esi, %r9d
addl %eax, %r9d
addl %r14d, %ebp
addl %r9d, %r14d
movl %ebp, %eax
roll $0x1a, %eax
movl %ebp, %esi
roll $0x15, %esi
xorl %eax, %esi
movl %ebp, %eax
roll $0x7, %eax
xorl %esi, %eax
movl %eax, -0x78(%rsp)
movl %r10d, %esi
xorl %r8d, %esi
movl %r15d, %eax
movl %r15d, %r9d
roll $0xf, %r9d
andl %ebp, %esi
movl %r15d, %r12d
roll $0xd, %r12d
movq %r13, %r15
movl -0x6c(%rsp,%r13,4), %r13d
xorl %r9d, %r12d
movl %r13d, %r9d
shrl $0xa, %eax
xorl %r12d, %eax
movl %r13d, %r12d
addl %r13d, %eax
movl %eax, -0x7c(%rsp)
roll $0x19, %r13d
roll $0xe, %r9d
xorl %r8d, %esi
xorl %r13d, %r9d
shrl $0x3, %r12d
xorl %r9d, %r12d
addl -0x4c(%rsp,%r15,4), %ecx
addl %r12d, %ecx
movl %ecx, -0x30(%rsp,%r15,4)
leaq 0x2ebb(%rip), %r9 # 0xca70
addl 0x10(%r9,%r15,4), %edi
addl %ecx, %edi
addl %esi, %edi
movl %edi, %esi
movl %r14d, %edi
roll $0x1e, %edi
addl -0x78(%rsp), %esi
movl %r14d, %eax
roll $0x13, %eax
xorl %edi, %eax
movl %r14d, %r9d
roll $0xa, %r9d
xorl %eax, %r9d
movl %r14d, %eax
andl %edx, %eax
movl %r14d, %edi
orl %edx, %edi
andl %r11d, %edi
orl %eax, %edi
addl %r9d, %edi
addl %esi, %ebx
movl %ebx, %eax
roll $0x1a, %eax
addl %esi, %edi
movl %ebx, %r9d
roll $0x15, %r9d
xorl %eax, %r9d
movl %ebx, %esi
roll $0x7, %esi
xorl %r9d, %esi
movl %ebp, %r9d
xorl %r10d, %r9d
andl %ebx, %r9d
movl -0x68(%rsp,%r15,4), %eax
movl %ecx, %r12d
roll $0xf, %r12d
movl %ecx, %r13d
roll $0xd, %r13d
xorl %r12d, %r13d
movl %eax, %r12d
shrl $0xa, %ecx
xorl %r13d, %ecx
movl %eax, %r13d
addl %eax, %ecx
roll $0x19, %eax
xorl %r10d, %r9d
roll $0xe, %r12d
xorl %eax, %r12d
movq %r15, %rax
movl -0x64(%rsp,%r15,4), %r15d
movl %r15d, -0x78(%rsp)
shrl $0x3, %r13d
movl -0x7c(%rsp), %r15d
addl -0x48(%rsp,%rax,4), %r15d
xorl %r12d, %r13d
addl %r13d, %r15d
leaq 0x2e05(%rip), %r12 # 0xca70
addl 0x14(%r12,%rax,4), %r8d
addl %r15d, %r8d
addl %r9d, %r8d
movl %r8d, %r9d
addl %esi, %r9d
movl %edi, %esi
roll $0x1e, %esi
movl %edi, %r8d
roll $0x13, %r8d
xorl %esi, %r8d
movl %edi, %esi
roll $0xa, %esi
xorl %r8d, %esi
movl %edi, %r12d
andl %r14d, %r12d
movl %edi, %r8d
orl %r14d, %r8d
andl %edx, %r8d
orl %r12d, %r8d
addl %esi, %r8d
addl %r9d, %r11d
addl %r9d, %r8d
movl %r11d, %esi
roll $0x1a, %esi
movl %r11d, %r12d
roll $0x15, %r12d
xorl %esi, %r12d
movl %r11d, %esi
roll $0x7, %esi
movl -0x78(%rsp), %eax
movl %eax, %r9d
movl %eax, %r13d
roll $0x19, %r13d
roll $0xe, %r9d
xorl %r12d, %esi
xorl %r13d, %r9d
movl -0x74(%rsp), %r13d
addl %eax, %r13d
movq -0x50(%rsp), %r12
movl %r15d, -0x2c(%rsp,%r12,4)
shrl $0x3, %eax
xorl %r9d, %eax
movl %ebx, %r9d
xorl %ebp, %r9d
andl %r11d, %r9d
addl -0x44(%rsp,%r12,4), %ecx
xorl %ebp, %r9d
addl %eax, %ecx
leaq 0x2d62(%rip), %rax # 0xca70
addl 0x18(%rax,%r12,4), %r10d
movl %ecx, -0x28(%rsp,%r12,4)
addl %ecx, %r10d
addl %r9d, %r10d
movl %r10d, %eax
addl %esi, %eax
movl %r8d, %esi
roll $0x1e, %esi
movl %r8d, %r9d
roll $0x13, %r9d
xorl %esi, %r9d
movl %r8d, %esi
roll $0xa, %esi
xorl %r9d, %esi
movl %r8d, %r9d
andl %edi, %r9d
movl %r8d, %r10d
orl %edi, %r10d
andl %r14d, %r10d
orl %r9d, %r10d
addl %esi, %r10d
addl %eax, %edx
addl %eax, %r10d
movl %edx, %eax
roll $0x1a, %eax
movl %edx, %r9d
roll $0x15, %r9d
xorl %eax, %r9d
movl %edx, %esi
roll $0x7, %esi
xorl %r9d, %esi
movl %r15d, %ecx
movl %r15d, %eax
roll $0xf, %eax
movl %r15d, %r9d
roll $0xd, %r9d
xorl %eax, %r9d
shrl $0xa, %ecx
movl -0x60(%rsp,%r12,4), %eax
movl %eax, %r15d
roll $0x19, %r15d
xorl %r9d, %ecx
movl %eax, %r9d
roll $0xe, %r9d
xorl %r15d, %r9d
movl %eax, %r15d
shrl $0x3, %r15d
xorl %r9d, %r15d
movl %r13d, %r9d
addl %r15d, %r9d
addl %ecx, %r9d
movl %r11d, %ecx
xorl %ebx, %ecx
andl %edx, %ecx
xorl %ebx, %ecx
movq %r12, %r15
leaq 0x2cae(%rip), %r12 # 0xca70
addl 0x1c(%r12,%r15,4), %ebp
movl %r9d, -0x24(%rsp,%r15,4)
addl %r9d, %ebp
addl %ecx, %ebp
movl %ebp, %ecx
addl %esi, %ecx
movl %r10d, %esi
roll $0x1e, %esi
movl %r10d, %r9d
roll $0x13, %r9d
xorl %esi, %r9d
movl %r10d, %esi
roll $0xa, %esi
xorl %r9d, %esi
movl %r10d, %r9d
andl %r8d, %r9d
movl %r10d, %ebp
orl %r8d, %ebp
andl %edi, %ebp
orl %r9d, %ebp
addl %esi, %ebp
addl %ecx, %r14d
addl %ecx, %ebp
cmpq $0x38, %r15
leaq 0x8(%r15), %rcx
jb 0x982b
movl %ebx, -0x54(%rsp)
movl %r14d, -0x60(%rsp)
movl %r11d, -0x58(%rsp)
movl %edx, -0x5c(%rsp)
movl %ebp, -0x70(%rsp)
movl %r10d, -0x6c(%rsp)
movl %r8d, -0x68(%rsp)
movl %edi, -0x64(%rsp)
xorl %eax, %eax
movq -0x48(%rsp), %rcx
movdqu (%rcx,%rax,4), %xmm0
paddd -0x70(%rsp,%rax,4), %xmm0
movdqu %xmm0, (%rcx,%rax,4)
addq $0x4, %rax
cmpq $0x8, %rax
jne 0x9e3f
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha256 | void mbedtls_sha256( const unsigned char *input, size_t ilen,
unsigned char output[32], int is224 )
{
mbedtls_sha256_context ctx;
mbedtls_sha256_init( &ctx );
mbedtls_sha256_starts( &ctx, is224 );
mbedtls_sha256_update( &ctx, input, ilen );
mbedtls_sha256_finish( &ctx, output );
mbedtls_sha256_free( &ctx );
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x60(%rsp)
testl %ecx, %ecx
je 0xa0ee
movaps 0x295d(%rip), %xmm0 # 0xca40
jne 0xa0f7
movaps 0x2964(%rip), %xmm1 # 0xca50
jmp 0xa0fe
movaps 0x293b(%rip), %xmm0 # 0xca30
je 0xa0e5
movaps 0x2962(%rip), %xmm1 # 0xca60
movq %rsp, %r14
movups %xmm0, 0x8(%r14)
movups %xmm1, 0x18(%r14)
movl %ecx, 0x68(%r14)
movq %r14, %rdi
callq 0x9e6b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9f25
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x6c, %rax
jne 0xa124
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha512_update | void mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *input,
size_t ilen )
{
size_t fill;
unsigned int left;
if( ilen == 0 )
return;
left = (unsigned int) (ctx->total[0] & 0x7F);
fill = 128 - left;
ctx->total[0] += (uint64_t) ilen;
if( ctx->total[0] < (uint64_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
mbedtls_sha512_process( ctx, ctx->buffer );
input += fill;
ilen -= fill;
left = 0;
}
while( ilen >= 128 )
{
mbedtls_sha512_process( ctx, input );
input += 128;
ilen -= 128;
}
if( ilen > 0 )
memcpy( (void *) (ctx->buffer + left), input, ilen );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xa967
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movl %ecx, %eax
andl $0x7f, %eax
movq %rcx, %rsi
addq %rdx, %rsi
movq %rsi, (%rdi)
jae 0xa8de
incq 0x8(%r14)
testl %eax, %eax
je 0xa91d
movl $0x80, %r15d
subl %eax, %r15d
movq %rdx, %r13
subq %r15, %r13
jb 0xa94c
leaq 0x50(%r14), %r12
andl $0x7f, %ecx
leaq (%r14,%rcx), %rdi
addq $0x50, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3100
movq %r14, %rdi
movq %r12, %rsi
callq 0xa3c4
addq %r15, %rbx
jmp 0xa920
movq %rdx, %r13
cmpq $0x80, %r13
jb 0xa942
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa3c4
subq $-0x80, %rbx
addq $-0x80, %r13
cmpq $0x7f, %r13
ja 0xa929
xorl %eax, %eax
movq %r13, %rdx
testq %r13, %r13
je 0xa967
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x50, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_sha512 | void mbedtls_sha512( const unsigned char *input, size_t ilen,
unsigned char output[64], int is384 )
{
mbedtls_sha512_context ctx;
mbedtls_sha512_init( &ctx );
mbedtls_sha512_starts( &ctx, is384 );
mbedtls_sha512_update( &ctx, input, ilen );
mbedtls_sha512_finish( &ctx, output );
mbedtls_sha512_free( &ctx );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movl $0xd8, %edx
xorl %esi, %esi
callq 0x30c0
testl %ebp, %ebp
je 0xac77
movaps 0x2140(%rip), %xmm0 # 0xcda0
movaps 0x2149(%rip), %xmm1 # 0xcdb0
movaps 0x2152(%rip), %xmm2 # 0xcdc0
movaps 0x215b(%rip), %xmm3 # 0xcdd0
jmp 0xac93
movaps 0x20e2(%rip), %xmm0 # 0xcd60
movaps 0x20eb(%rip), %xmm1 # 0xcd70
movaps 0x20f4(%rip), %xmm2 # 0xcd80
movaps 0x20fd(%rip), %xmm3 # 0xcd90
leaq 0x8(%rsp), %r12
movups %xmm3, 0x10(%r12)
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x30(%r12)
movups %xmm0, 0x40(%r12)
movl %ebp, 0xd0(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa8af
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa971
xorl %eax, %eax
movb $0x0, 0x8(%rsp,%rax)
incq %rax
cmpq $0xd8, %rax
jne 0xacd3
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_md5_starts | void mbedtls_md5_starts( mbedtls_md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
} | movaps 0x174d(%rip), %xmm0 # 0xc6b0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
retq
| /Dragonchang[P]https_client/mbedtls/library/md5.c |
mbedtls_md5 | void mbedtls_md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
mbedtls_md5_context ctx;
mbedtls_md5_init( &ctx );
mbedtls_md5_starts( &ctx );
mbedtls_md5_update( &ctx, input, ilen );
mbedtls_md5_finish( &ctx, output );
mbedtls_md5_free( &ctx );
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movq $0x0, 0x50(%r14)
movaps 0xd9d(%rip), %xmm0 # 0xc6c0
movups %xmm0, 0x8(%r14)
movq %r14, %rdi
callq 0xb72a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb7e4
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x58, %rax
jne 0xb93d
addq $0x58, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/md5.c |
lshift | static Bigint *
lshift(Bigint *b, int k MTd)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
#ifdef Pack_32
n = k >> 5;
#else
n = k >> 4;
#endif
k1 = b->k;
n1 = n + b->wds + 1;
for(i = b->maxwds; n1 > i; i <<= 1)
k1++;
b1 = Balloc(k1 MTa);
x1 = b1->x;
for(i = 0; i < n; i++)
*x1++ = 0;
x = b->x;
xe = x + b->wds;
#ifdef Pack_32
if (k &= 0x1f) {
k1 = 32 - k;
z = 0;
do {
*x1++ = *x << k | z;
z = *x++ >> k1;
}
while(x < xe);
if ((*x1 = z))
++n1;
}
#else
if (k &= 0xf) {
k1 = 16 - k;
z = 0;
do {
*x1++ = *x << k & 0xffff | z;
z = *x++ >> k1;
}
while(x < xe);
if (*x1 = z)
++n1;
}
#endif
else do
*x1++ = *x++;
while(x < xe);
b1->wds = n1 - 1;
Bfree(b MTa);
return b1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r12d
sarl $0x5, %r12d
movl 0x8(%rdi), %edi
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %r15d
addl %r12d, %r15d
cmpl %eax, %r15d
jl 0x5b73
incl %edi
addl %eax, %eax
jmp 0x5b68
callq 0x5775
movq %rax, %r14
leaq 0x18(%rax), %rdi
testl %r12d, %r12d
jle 0x5b9d
movl %r12d, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x8194
decl %r12d
leaq (%r14,%r12,4), %rdi
addq $0x1c, %rdi
leaq 0x18(%rbx), %rdx
movslq 0x14(%rbx), %rax
leaq (%rbx,%rax,4), %rsi
addq $0x18, %rsi
andl $0x1f, %ebp
je 0x5bec
movl $0x20, %eax
subl %ebp, %eax
xorl %r8d, %r8d
movl (%rdx), %r9d
movl %ebp, %ecx
shll %cl, %r9d
orl %r8d, %r9d
movl %r9d, (%rdi)
addq $0x4, %rdi
movl (%rdx), %r8d
addq $0x4, %rdx
movl %eax, %ecx
shrl %cl, %r8d
cmpq %rsi, %rdx
jb 0x5bbc
movl %r8d, (%rdi)
cmpl $0x1, %r8d
sbbl $-0x1, %r15d
jmp 0x5bfd
movl (%rdx), %eax
addq $0x4, %rdx
movl %eax, (%rdi)
addq $0x4, %rdi
cmpq %rsi, %rdx
jb 0x5bec
movl %r15d, 0x14(%r14)
testq %rbx, %rbx
je 0x5c2c
movslq 0x8(%rbx), %rax
cmpq $0x8, %rax
jl 0x5c1a
movq %rbx, %rdi
callq 0x9692
jmp 0x5c2c
leaq 0x110af(%rip), %rcx # 0x16cd0
movq (%rcx,%rax,8), %rdx
movq %rdx, (%rbx)
movq %rbx, (%rcx,%rax,8)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
PDCLIB_freedtoa | void
_PDCLIB_freedtoa(char *s)
{
#ifdef MULTIPLE_THREADS
ThInfo *TI = 0;
#endif
Bigint *b = (Bigint *)((int *)s - 1);
b->maxwds = 1 << (b->k = *(int*)b);
Bfree(b MTb);
#ifndef MULTIPLE_THREADS
if (s == dtoa_result)
dtoa_result = 0;
#endif
} | pushq %rbx
movq %rdi, %rbx
movslq -0x4(%rdi), %rcx
movl $0x1, %eax
shll %cl, %eax
addq $-0x4, %rdi
movl %ecx, 0x4(%rbx)
movl %eax, 0x8(%rbx)
cmpq $0x8, %rcx
jl 0x61d2
callq 0x9692
jmp 0x61e4
leaq 0x10af7(%rip), %rax # 0x16cd0
movq (%rax,%rcx,8), %rdx
movq %rdx, (%rdi)
movq %rdi, (%rax,%rcx,8)
cmpq %rbx, 0x10ad5(%rip) # 0x16cc0
jne 0x61f8
movq $0x0, 0x10ac8(%rip) # 0x16cc0
popq %rbx
retq
| /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
hi0bits | static int
hi0bits(ULong x)
{
int k = 0;
if (!(x & 0xffff0000)) {
k = 16;
x <<= 16;
}
if (!(x & 0xff000000)) {
k += 8;
x <<= 8;
}
if (!(x & 0xf0000000)) {
k += 4;
x <<= 4;
}
if (!(x & 0xc0000000)) {
k += 2;
x <<= 2;
}
if (!(x & 0x80000000)) {
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x10000000, %edx # imm = 0x10000000
cmovael %edx, %ecx
leal 0x4(%rax), %edx
cmovael %eax, %edx
leal (,%rcx,4), %esi
movl $0x40000000, %eax # imm = 0x40000000
cmpl %eax, %ecx
cmovael %ecx, %esi
leal 0x2(%rdx), %ecx
cmovael %edx, %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %esi
movl $0x20, %eax
cmovael %edx, %eax
testl %esi, %esi
cmovsl %ecx, %eax
retq
| /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
rshift | static void
rshift(Bigint *b, int k)
{
ULong *x, *x1, *xe, y;
int n;
x = x1 = b->x;
n = k >> kshift;
if (n < b->wds) {
xe = x + b->wds;
x += n;
if (k &= kmask) {
n = 32 - k;
y = *x++ >> k;
while(x < xe) {
*x1++ = (y | (*x << n)) & 0xffffffff;
y = *x++ >> k;
}
if ((*x1 = y) !=0)
x1++;
}
else
while(x < xe)
*x1++ = *x++;
}
if ((b->wds = x1 - b->x) == 0)
b->x[0] = 0;
} | pushq %rbp
pushq %rbx
leaq 0x18(%rdi), %rdx
movl %esi, %r9d
shrl $0x5, %r9d
movl 0x14(%rdi), %r10d
movq %rdx, %rcx
cmpl %r10d, %r9d
jge 0x7b7a
leaq (%rdx,%r10,4), %r8
movl %r9d, %eax
andl $0x1f, %esi
je 0x7b3e
leaq (%rdx,%rax,4), %r9
movl (%r9), %r11d
addq $0x4, %r9
movl %esi, %ecx
shrl %cl, %r11d
cmpq %r8, %r9
jae 0x7b66
movl $0x20, %eax
subl %esi, %eax
movq %rdx, %r10
movl (%r9), %ebx
movl %ebx, %ebp
movl %eax, %ecx
shll %cl, %ebp
orl %r11d, %ebp
movl %ebp, (%r10)
movl %esi, %ecx
shrl %cl, %ebx
addq $0x4, %r10
addq $0x4, %r9
movl %ebx, %r11d
cmpq %r8, %r9
jb 0x7b19
jmp 0x7b6c
movq %rdx, %rcx
cmpl %r10d, %r9d
jae 0x7b7a
shll $0x2, %eax
movq %rdx, %rcx
leaq (%rcx,%rax), %rsi
addq $0x4, %rsi
movl -0x4(%rsi), %r9d
movl %r9d, (%rcx)
addq $0x4, %rcx
cmpq %r8, %rsi
jb 0x7b4c
jmp 0x7b7a
movq %rdx, %r10
movl %r11d, %ebx
movl %ebx, (%r10)
xorl %eax, %eax
testl %ebx, %ebx
setne %al
leaq (%r10,%rax,4), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movl %ecx, 0x14(%rdi)
testl %ecx, %ecx
jne 0x7b8e
movl $0x0, (%rdx)
popq %rbx
popq %rbp
retq
| /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
increment | static Bigint *
increment(Bigint *b MTd)
{
ULong *x, *xe;
Bigint *b1;
x = b->x;
xe = x + b->wds;
do {
if (*x < (ULong)0xffffffffL) {
++*x;
return b;
}
*x++ = 0;
} while(x < xe);
{
if (b->wds >= b->maxwds) {
b1 = Balloc(b->k+1 MTa);
Bcopy(b1,b);
Bfree(b MTa);
b = b1;
}
b->x[b->wds++] = 1;
}
return b;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movslq 0x14(%rdi), %rcx
leaq (%rdi,%rcx,4), %rcx
addq $0x18, %rcx
movl (%rax), %edx
cmpl $-0x1, %edx
jne 0x7c8d
movl $0x0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
jb 0x7c6a
movl 0x14(%rbx), %eax
cmpl 0xc(%rbx), %eax
jge 0x7c93
movq %rbx, %r14
jmp 0x7ce4
incl %edx
movl %edx, (%rax)
jmp 0x7cfb
movl 0x8(%rbx), %edi
incl %edi
callq 0x5775
movq %rax, %r14
leaq 0x10(%rax), %rdi
leaq 0x10(%rbx), %rsi
movslq 0x14(%rbx), %rax
leaq 0x8(,%rax,4), %rdx
callq 0x8178
testq %rbx, %rbx
je 0x7ce4
movslq 0x8(%rbx), %rax
cmpq $0x8, %rax
jl 0x7cd2
movq %rbx, %rdi
callq 0x9692
jmp 0x7ce4
leaq 0xeff7(%rip), %rcx # 0x16cd0
movq (%rcx,%rax,8), %rdx
movq %rdx, (%rbx)
movq %rbx, (%rcx,%rax,8)
movslq 0x14(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%r14)
movl $0x1, 0x18(%r14,%rax,4)
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /DevSolar[P]pdclib/functions/_dtoa/dtoa.c |
ialloc | static void** ialloc(mstate m,
size_t n_elements,
size_t* sizes,
int opts,
void* chunks[]) {
size_t element_size; /* chunksize of each element, if all same */
size_t contents_size; /* total size of elements */
size_t array_size; /* request size of pointer array */
void* mem; /* malloced aggregate space */
mchunkptr p; /* corresponding chunk */
size_t remainder_size; /* remaining bytes while splitting */
void** marray; /* either "chunks" or malloced ptr array */
mchunkptr array_chunk; /* chunk for malloced ptr array */
flag_t was_enabled; /* to disable mmap */
size_t size;
size_t i;
ensure_initialization();
/* compute array length, if needed */
if (chunks != 0) {
if (n_elements == 0)
return chunks; /* nothing to do */
marray = chunks;
array_size = 0;
}
else {
/* if empty req, must still return chunk representing empty array */
if (n_elements == 0)
return (void**)internal_malloc(m, 0);
marray = 0;
array_size = request2size(n_elements * (sizeof(void*)));
}
/* compute total element size */
if (opts & 0x1) { /* all-same-size */
element_size = request2size(*sizes);
contents_size = n_elements * element_size;
}
else { /* add up all the sizes */
element_size = 0;
contents_size = 0;
for (i = 0; i != n_elements; ++i)
contents_size += request2size(sizes[i]);
}
size = contents_size + array_size;
/*
Allocate the aggregate chunk. First disable direct-mmapping so
malloc won't use it, since we would not be able to later
free/realloc space internal to a segregated mmap region.
*/
was_enabled = use_mmap(m);
disable_mmap(m);
mem = internal_malloc(m, size - CHUNK_OVERHEAD);
if (was_enabled)
enable_mmap(m);
if (mem == 0)
return 0;
if (PREACTION(m)) return 0;
p = mem2chunk(mem);
remainder_size = chunksize(p);
assert(!is_mmapped(p));
if (opts & 0x2) { /* optionally clear the elements */
memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
}
/* If not provided, allocate the pointer array as final part of chunk */
if (marray == 0) {
size_t array_chunk_size;
array_chunk = chunk_plus_offset(p, contents_size);
array_chunk_size = remainder_size - contents_size;
marray = (void**) (chunk2mem(array_chunk));
set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
remainder_size = contents_size;
}
/* split out elements */
for (i = 0; ; ++i) {
marray[i] = chunk2mem(p);
if (i != n_elements-1) {
if (element_size != 0)
size = element_size;
else
size = request2size(sizes[i]);
remainder_size -= size;
set_size_and_pinuse_of_inuse_chunk(m, p, size);
p = chunk_plus_offset(p, size);
}
else { /* the final element absorbs any overallocation slop */
set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
break;
}
}
#if DEBUG
if (marray != chunks) {
/* final element must have exactly exhausted chunk */
if (element_size != 0) {
assert(remainder_size == element_size);
}
else {
assert(remainder_size == request2size(sizes[i]));
}
check_inuse_chunk(m, mem2chunk(marray));
}
for (i = 0; i != n_elements; ++i)
check_inuse_chunk(m, mem2chunk(marray[i]));
#endif /* DEBUG */
POSTACTION(m);
return marray;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0xc9a2(%rip) # 0x17620
jne 0xac85
callq 0x95d8
testq %rbx, %rbx
je 0xac97
testq %r15, %r15
je 0xae9b
xorl %edi, %edi
jmp 0xacc3
testq %r15, %r15
je 0xad26
leaq (,%r15,8), %rax
leaq 0x17(,%r15,8), %rcx
andq $-0x10, %rcx
cmpq $0x17, %rax
movl $0x20, %edi
cmovaeq %rcx, %rdi
xorl %ebx, %ebx
testb $0x1, %bpl
movq %r14, 0x20(%rsp)
movl %ebp, 0x14(%rsp)
jne 0xad04
testq %r15, %r15
je 0xad3b
xorl %r13d, %r13d
movl $0x20, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
movq (%r14,%rcx,8), %rdx
leaq 0x17(%rdx), %rsi
andq $-0x10, %rsi
cmpq $0x17, %rdx
cmovbq %rax, %rsi
addq %rsi, %rbp
incq %rcx
cmpq %rcx, %r15
jne 0xace3
jmp 0xad40
movq (%r14), %rax
leaq 0x17(%rax), %rcx
andq $-0x10, %rcx
cmpq $0x17, %rax
movl $0x20, %r13d
cmovaeq %rcx, %r13
movq %r13, %rbp
imulq %r15, %rbp
jmp 0xad40
xorl %edi, %edi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x81ac
xorl %ebp, %ebp
xorl %r13d, %r13d
movl 0xcc79(%rip), %r14d # 0x179c0
movl %r14d, %eax
andl $-0x2, %eax
movl %eax, 0xcc6d(%rip) # 0x179c0
movq %rdi, 0x18(%rsp)
addq %rbp, %rdi
addq $-0x8, %rdi
callq 0x81ac
movq %rax, %r12
testb $0x1, %r14b
je 0xad74
orb $0x1, 0xcc4c(%rip) # 0x179c0
testq %r12, %r12
je 0xae02
movq %r12, 0x8(%rsp)
testb $0x2, 0xcc37(%rip) # 0x179c0
je 0xadc8
movl $0x1, %r14d
movl $0x1, %eax
xchgl %eax, 0xcc28(%rip) # 0x179c4
testl %eax, %eax
jne 0xadb0
jmp 0xadc8
testb $0x3f, %r14b
jne 0xadad
callq 0x30b0
incl %r14d
cmpl $0x0, 0xcc0d(%rip) # 0x179c4
jne 0xada2
movl $0x1, %eax
xchgl %eax, 0xcc00(%rip) # 0x179c4
testl %eax, %eax
jne 0xada2
movq 0x8(%rsp), %rax
movq -0x8(%rax), %r14
andq $-0x8, %r14
testb $0x2, 0x14(%rsp)
je 0xadf4
movq %r14, %rdx
subq 0x18(%rsp), %rdx
addq $-0x8, %rdx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x8194
addq $-0x10, %r12
testq %rbx, %rbx
je 0xae09
movq %r14, %rbp
jmp 0xae1c
xorl %ebx, %ebx
jmp 0xae9b
subq %rbp, %r14
leaq (%r12,%rbp), %rbx
addq $0x10, %rbx
orq $0x3, %r14
movq %r14, -0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
decq %r15
movq 0x20(%rsp), %rdi
je 0xae7d
xorl %eax, %eax
movl $0x20, %ecx
movq %r13, %rsi
testq %r13, %r13
jne 0xae51
movq (%rdi,%rax,8), %rdx
leaq 0x17(%rdx), %rsi
andq $-0x10, %rsi
cmpq $0x17, %rdx
cmovbq %rcx, %rsi
subq %rsi, %rbp
movq %rsi, %rdx
orq $0x3, %rdx
movq %rdx, 0x8(%r12)
leaq (%r12,%rsi), %rdx
addq %r12, %rsi
addq $0x10, %rsi
movq %rsi, 0x8(%rbx,%rax,8)
incq %rax
movq %rdx, %r12
cmpq %rax, %r15
jne 0xae35
jmp 0xae80
movq %r12, %rdx
orq $0x3, %rbp
movq %rbp, 0x8(%rdx)
testb $0x2, 0xcb31(%rip) # 0x179c0
je 0xae9b
movl $0x0, 0xcb29(%rip) # 0x179c4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->base = 0;
status->current = 0;
status->width = 0;
status->prec = EOF;
/* First come 0..n flags */
do
{
switch ( *spec )
{
case '-':
/* left-aligned output */
status->flags |= E_minus;
++spec;
break;
case '+':
/* positive numbers prefixed with '+' */
status->flags |= E_plus;
++spec;
break;
case '#':
/* alternative format (leading 0x for hex, 0 for octal) */
status->flags |= E_alt;
++spec;
break;
case ' ':
/* positive numbers prefixed with ' ' */
status->flags |= E_space;
++spec;
break;
case '0':
/* right-aligned padding done with '0' instead of ' ' */
status->flags |= E_zero;
++spec;
break;
default:
/* not a flag, exit flag parsing */
status->flags |= E_done;
break;
}
} while ( !( status->flags & E_done ) );
/* Optional field width */
if ( *spec == '*' )
{
/* Retrieve width value from argument stack */
int width = va_arg( status->arg, int );
if ( width < 0 )
{
status->flags |= E_minus;
status->width = abs( width );
}
else
{
status->width = width;
}
++spec;
}
else
{
/* If a width is given, strtol() will return its value. If not given,
strtol() will return zero. In both cases, endptr will point to the
rest of the conversion specifier - just what we need.
*/
status->width = ( int )strtol( spec, ( char ** )&spec, 10 );
}
/* Optional precision */
if ( *spec == '.' )
{
++spec;
if ( *spec == '*' )
{
/* Retrieve precision value from argument stack. A negative value
is as if no precision is given - as precision is initalized to
EOF (negative), there is no need for testing for negative here.
*/
status->prec = va_arg( status->arg, int );
++spec;
}
else
{
char * endptr;
status->prec = ( int )strtol( spec, &endptr, 10 );
if ( spec == endptr )
{
/* Decimal point but no number - equals zero */
status->prec = 0;
}
spec = endptr;
}
/* Having a precision cancels out any zero flag. */
status->flags &= ~E_zero;
}
/* Optional length modifier
We step one character ahead in any case, and step back only if we find
there has been no length modifier (or step ahead another character if it
has been "hh" or "ll").
*/
switch ( *( spec++ ) )
{
case 'h':
if ( *spec == 'h' )
{
/* hh -> char */
status->flags |= E_char;
++spec;
}
else
{
/* h -> short */
status->flags |= E_short;
}
break;
case 'l':
if ( *spec == 'l' )
{
/* ll -> long long */
status->flags |= E_llong;
++spec;
}
else
{
/* k -> long */
status->flags |= E_long;
}
break;
case 'j':
/* j -> intmax_t, which might or might not be long long */
status->flags |= E_intmax;
break;
case 'z':
/* z -> size_t, which might or might not be unsigned int */
status->flags |= E_size;
break;
case 't':
/* t -> ptrdiff_t, which might or might not be long */
status->flags |= E_ptrdiff;
break;
case 'L':
/* L -> long double */
status->flags |= E_ldouble;
break;
default:
--spec;
break;
}
/* Conversion specifier */
switch ( *spec )
{
case 'd':
/* FALLTHROUGH */
case 'i':
status->base = 10;
break;
case 'o':
status->base = 8;
status->flags |= E_unsigned;
break;
case 'u':
status->base = 10;
status->flags |= E_unsigned;
break;
case 'x':
status->base = 16;
status->flags |= ( E_lower | E_unsigned );
break;
case 'X':
status->base = 16;
status->flags |= E_unsigned;
break;
case 'f':
status->base = 2;
status->flags |= ( E_decimal | E_double | E_lower );
break;
case 'F':
status->base = 2;
status->flags |= ( E_decimal | E_double );
break;
case 'e':
status->base = 2;
status->flags |= ( E_exponent | E_double | E_lower );
break;
case 'E':
status->base = 2;
status->flags |= ( E_exponent | E_double );
break;
case 'g':
status->base = 2;
status->flags |= ( E_generic | E_double | E_lower );
break;
case 'G':
status->base = 2;
status->flags |= ( E_generic | E_double );
break;
case 'a':
status->base = 2;
status->flags |= ( E_hexa | E_double | E_lower );
break;
case 'A':
status->base = 2;
status->flags |= ( E_hexa | E_double );
break;
case 'c':
/* TODO: wide chars. */
{
char c[1];
c[0] = ( char )va_arg( status->arg, int );
status->flags |= E_char;
_PDCLIB_print_string( c, status );
return ++spec;
}
case 's':
/* TODO: wide chars. */
_PDCLIB_print_string( va_arg( status->arg, char * ), status );
return ++spec;
case 'p':
status->base = 16;
status->flags |= ( E_lower | E_unsigned | E_alt | E_pointer );
break;
case 'n':
{
int * val = va_arg( status->arg, int * );
*val = status->i;
return ++spec;
}
default:
/* No conversion specifier. Bad conversion. */
return orig_spec;
}
/* Do the actual output based on our findings */
if ( status->base != 0 )
{
/* TODO: Check for invalid flag combinations. */
if ( status->flags & E_double )
{
/* Floating Point conversions */
if ( status->flags & E_ldouble )
{
long double value = va_arg( status->arg, long double );
_PDCLIB_print_ldouble( value, status );
}
else
{
double value = va_arg( status->arg, double );
_PDCLIB_print_double( value, status );
}
}
else
{
if ( status->flags & E_unsigned )
{
/* Integer conversions (unsigned) */
uintmax_t value;
imaxdiv_t div;
switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_size | E_pointer | E_intmax ) )
{
case E_char:
value = ( uintmax_t )( unsigned char )va_arg( status->arg, int );
break;
case E_short:
value = ( uintmax_t )( unsigned short )va_arg( status->arg, int );
break;
case 0:
value = ( uintmax_t )va_arg( status->arg, unsigned int );
break;
case E_long:
value = ( uintmax_t )va_arg( status->arg, unsigned long );
break;
case E_llong:
value = ( uintmax_t )va_arg( status->arg, unsigned long long );
break;
case E_size:
value = ( uintmax_t )va_arg( status->arg, size_t );
break;
case E_pointer:
value = ( uintmax_t )( uintptr_t )va_arg( status->arg, void * );
break;
case E_intmax:
value = va_arg( status->arg, uintmax_t );
break;
default:
puts( "UNSUPPORTED PRINTF FLAG COMBINATION" );
return NULL;
}
div.quot = value / status->base;
div.rem = value % status->base;
_PDCLIB_print_integer( div, status );
}
else
{
/* Integer conversions (signed) */
intmax_t value;
switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_intmax ) )
{
case E_char:
value = ( intmax_t )( char )va_arg( status->arg, int );
break;
case E_short:
value = ( intmax_t )( short )va_arg( status->arg, int );
break;
case 0:
value = ( intmax_t )va_arg( status->arg, int );
break;
case E_long:
value = ( intmax_t )va_arg( status->arg, long );
break;
case E_llong:
value = ( intmax_t )va_arg( status->arg, long long );
break;
case E_ptrdiff:
value = ( intmax_t )va_arg( status->arg, ptrdiff_t );
break;
case E_intmax:
value = va_arg( status->arg, intmax_t );
break;
default:
puts( "UNSUPPORTED PRINTF FLAG COMBINATION" );
return NULL;
}
_PDCLIB_print_integer( imaxdiv( value, status->base ), status );
}
}
if ( status->flags & E_minus )
{
/* Left-aligned filling */
while ( status->current < status->width )
{
PUT( ' ' );
++( status->current );
}
}
if ( status->i >= status->n && status->n > 0 )
{
status->s[status->n - 1] = '\0';
}
}
return ++spec;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%rsp)
movb 0x1(%rdi), %al
cmpb $0x25, %al
jne 0xbe5b
movq 0x10(%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jae 0xbf8b
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0xbf84
movl $0x25, %edi
callq 0xd14c
jmp 0xbf8b
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x28(%rbx)
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rdi
movzbl (%rdi), %ecx
cmpl $0x2a, %ecx
jle 0xbe90
cmpl $0x2b, %ecx
je 0xbe9f
cmpl $0x30, %ecx
je 0xbea4
cmpl $0x2d, %ecx
jne 0xbeb8
orl $0x1, %eax
jmp 0xbeac
cmpl $0x20, %ecx
je 0xbea9
cmpl $0x23, %ecx
jne 0xbeb8
orl $0x4, %eax
jmp 0xbeac
orl $0x2, %eax
jmp 0xbeac
orl $0x10, %eax
jmp 0xbeac
orl $0x8, %eax
movl %eax, 0x4(%rbx)
incq %rdi
testb $0x20, %al
je 0xbe74
jmp 0xbec0
orl $0x20, %eax
movl %eax, 0x4(%rbx)
jmp 0xbeb2
movq %rdi, 0x18(%rsp)
cmpb $0x2a, (%rdi)
jne 0xbee2
movl 0x40(%rbx), %edx
cmpq $0x28, %rdx
ja 0xbef9
movq %rdx, %rcx
addq 0x50(%rbx), %rcx
addl $0x8, %edx
movl %edx, 0x40(%rbx)
jmp 0xbf05
leaq 0x18(%rsp), %rsi
movl $0xa, %edx
callq 0xd284
cltq
movq %rax, 0x28(%rbx)
jmp 0xbf21
movq 0x48(%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movl (%rcx), %ecx
testl %ecx, %ecx
jns 0xbf13
orl $0x1, %eax
movl %eax, 0x4(%rbx)
negl %ecx
movl %ecx, %eax
movq %rax, 0x28(%rbx)
incq %rdi
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpb $0x2e, (%rax)
jne 0xbfbb
leaq 0x1(%rax), %r15
movq %r15, 0x18(%rsp)
cmpb $0x2a, 0x1(%rax)
jne 0xbf56
movl 0x40(%rbx), %edx
cmpq $0x28, %rdx
ja 0xbf9d
movq %rdx, %rcx
addq 0x50(%rbx), %rcx
addl $0x8, %edx
movl %edx, 0x40(%rbx)
jmp 0xbfa9
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0xd284
movl %eax, 0x30(%rbx)
movq (%r12), %rcx
xorl %edx, %edx
cmpq %rcx, %r15
cmovnel %eax, %edx
movl %edx, 0x30(%rbx)
movq %rcx, 0x18(%rsp)
jmp 0xbfb7
movq 0x20(%rbx), %rdx
movb %al, (%rdx,%rcx)
incq 0x10(%rbx)
addq $0x2, %r14
movq %r14, 0x18(%rsp)
jmp 0xc4b4
movq 0x48(%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x48(%rbx)
movl (%rcx), %ecx
movl %ecx, 0x30(%rbx)
addq $0x2, %rax
movq %rax, 0x18(%rsp)
andb $-0x11, 0x4(%rbx)
movq 0x18(%rsp), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rsp)
movzbl (%rax), %ecx
cmpl $0x6b, %ecx
jg 0xbfe6
cmpl $0x4c, %ecx
je 0xbffb
cmpl $0x68, %ecx
je 0xc011
cmpl $0x6a, %ecx
jne 0xc023
orb $0x4, 0x5(%rbx)
jmp 0xc041
cmpl $0x6c, %ecx
je 0xc001
cmpl $0x74, %ecx
je 0xc02a
cmpl $0x7a, %ecx
jne 0xc023
orb $0x8, 0x5(%rbx)
jmp 0xc041
orb $-0x80, 0x5(%rbx)
jmp 0xc041
cmpb $0x6c, (%rdx)
movl 0x4(%rbx), %ecx
jne 0xc030
orl $0x200, %ecx # imm = 0x200
jmp 0xc01c
cmpb $0x68, (%rdx)
movl 0x4(%rbx), %ecx
jne 0xc038
orl $0x40, %ecx
movl %ecx, 0x4(%rbx)
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0xc041
orb $0x10, 0x5(%rbx)
jmp 0xc041
orl $0x100, %ecx # imm = 0x100
jmp 0xc03e
orl $0x80, %ecx
movl %ecx, 0x4(%rbx)
movq 0x18(%rsp), %r15
movzbl (%r15), %eax
leal -0x58(%rax), %ecx
cmpl $0x20, %ecx
ja 0xc06d
leaq 0x5f1b(%rip), %rax # 0x11f74
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0xa, (%rbx)
jmp 0xc1a5
addl $-0x41, %eax
cmpl $0x6, %eax
ja 0xc4b4
leaq 0x5ed8(%rip), %rcx # 0x11f58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, (%rbx)
orl $0x204000, 0x4(%rbx) # imm = 0x204000
jmp 0xc1a5
movl $0x10, (%rbx)
orb $0x3, 0x6(%rbx)
jmp 0xc1a5
movl $0x8, (%rbx)
jmp 0xc174
movl $0x2, (%rbx)
orl $0x54000, 0x4(%rbx) # imm = 0x54000
jmp 0xc1a5
movl $0x2, (%rbx)
orl $0x94000, 0x4(%rbx) # imm = 0x94000
jmp 0xc1a5
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc374
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc380
movl $0x2, (%rbx)
orl $0x214000, 0x4(%rbx) # imm = 0x214000
jmp 0xc1a5
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc38d
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc399
movl $0x10, (%rbx)
jmp 0xc174
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc3a8
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc3b4
movl $0x2, (%rbx)
orl $0x114000, 0x4(%rbx) # imm = 0x114000
jmp 0xc1a5
movl $0x10, (%rbx)
orl $0x32004, 0x4(%rbx) # imm = 0x32004
jmp 0xc1a5
movl $0xa, (%rbx)
orb $0x2, 0x6(%rbx)
jmp 0xc1a5
movl $0x2, (%rbx)
orl $0x84000, 0x4(%rbx) # imm = 0x84000
jmp 0xc1a5
movl $0x2, (%rbx)
orl $0x44000, 0x4(%rbx) # imm = 0x44000
jmp 0xc1a5
movl $0x2, (%rbx)
orl $0x104000, 0x4(%rbx) # imm = 0x104000
movslq (%rbx), %rsi
testq %rsi, %rsi
je 0xc4a9
movl 0x4(%rbx), %eax
btl $0xe, %eax
jb 0xc20b
btl $0x11, %eax
jb 0xc232
andl $0x7c0, %eax # imm = 0x7C0
cmpl $0xff, %eax
jg 0xc2a1
testl %eax, %eax
je 0xc3d8
cmpl $0x40, %eax
je 0xc3f0
cmpl $0x80, %eax
jne 0xc360
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc457
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc463
testw %ax, %ax
js 0xc27b
movl 0x44(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0xc2d9
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x44(%rbx)
jmp 0xc2e5
andl $0x2fc0, %eax # imm = 0x2FC0
cmpl $0x1ff, %eax # imm = 0x1FF
jg 0xc2f6
cmpl $0x7f, %eax
jg 0xc30d
testl %eax, %eax
je 0xc408
cmpl $0x40, %eax
jne 0xc360
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc52c
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc538
movq 0x48(%rbx), %rax
addq $0xf, %rax
andq $-0x10, %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x48(%rbx)
fldt (%rax)
fstpt (%rsp)
movq %rbx, %rdi
callq 0xcbb1
jmp 0xc48c
cmpl $0x100, %eax # imm = 0x100
je 0xc2ba
cmpl $0x200, %eax # imm = 0x200
je 0xc2ba
cmpl $0x400, %eax # imm = 0x400
jne 0xc360
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc3c4
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc3d0
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0xc540
jmp 0xc48c
cmpl $0x7ff, %eax # imm = 0x7FF
jg 0xc321
cmpl $0x200, %eax # imm = 0x200
je 0xc32f
cmpl $0x400, %eax # imm = 0x400
je 0xc32f
jmp 0xc360
cmpl $0x80, %eax
je 0xc427
cmpl $0x100, %eax # imm = 0x100
je 0xc32f
jmp 0xc360
cmpl $0x800, %eax # imm = 0x800
je 0xc32f
cmpl $0x2000, %eax # imm = 0x2000
jne 0xc360
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc347
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc353
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq (%rax), %rax
xorl %edx, %edx
divq %rsi
jmp 0xc47e
leaq 0x5c91(%rip), %rdi # 0x11ff8
callq 0xd154
xorl %r14d, %r14d
jmp 0xc4b4
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq (%rax), %rax
movl 0x10(%rbx), %ecx
movl %ecx, (%rax)
jmp 0xc4a9
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movb (%rax), %al
leaq 0x20(%rsp), %rdi
movb %al, (%rdi)
orb $0x40, 0x4(%rbx)
jmp 0xc3b7
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xcebc
jmp 0xc4a9
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq (%rax), %rdi
jmp 0xc479
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc446
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc452
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc469
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc475
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc505
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc511
movl 0x40(%rbx), %ecx
cmpq $0x28, %rcx
ja 0xc518
movq %rcx, %rax
addq 0x50(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x40(%rbx)
jmp 0xc524
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movslq (%rax), %rdi
jmp 0xc479
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movswq (%rax), %rdi
jmp 0xc479
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movsbq (%rax), %rdi
callq 0xd0bc
movq %rax, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xcc10
testb $0x1, 0x4(%rbx)
jne 0xc4c3
movq 0x8(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq 0x10(%rbx), %rcx
jae 0xc4a9
movq 0x20(%rbx), %rcx
movb $0x0, -0x1(%rcx,%rax)
incq %r15
movq %r15, 0x18(%rsp)
movq %r15, %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%rbx), %rax
cmpq 0x28(%rbx), %rax
jae 0xc492
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0xc4f4
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0xc4ec
movl $0x20, %edi
callq 0xd14c
jmp 0xc4f4
movq 0x20(%rbx), %rcx
movb $0x20, (%rcx,%rax)
incq 0x10(%rbx)
movq 0x18(%rbx), %rax
incq %rax
movq %rax, 0x18(%rbx)
jmp 0xc4c7
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movl (%rax), %eax
jmp 0xc356
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movzwl (%rax), %eax
jmp 0xc356
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movzbl (%rax), %eax
jmp 0xc356
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
fputs | int fputs( const char * _PDCLIB_restrict s, struct _PDCLIB_file_t * _PDCLIB_restrict stream )
{
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
while ( *s != '\0' )
{
/* Unbuffered and line buffered streams get flushed when fputs() does
write the terminating end-of-line. All streams get flushed if the
buffer runs full.
*/
stream->buffer[ stream->bufidx++ ] = *s;
if ( ( stream->bufidx == stream->bufsize ) ||
( ( stream->status & _IOLBF ) && *s == '\n' )
)
{
if ( _PDCLIB_flushbuffer( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
}
++s;
}
if ( stream->status & _IONBF )
{
if ( _PDCLIB_flushbuffer( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
}
_PDCLIB_UNLOCK( stream->mtx );
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rsi), %rbx
movq %rbx, %rdi
callq 0xd08c
movq %r14, %rdi
callq 0xbdc4
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0xd90f
movb (%r15), %al
testb %al, %al
je 0xd8f9
incq %r15
movq 0x8(%r14), %rcx
movq 0x18(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x18(%r14)
movb %al, (%rcx,%rdx)
movq 0x18(%r14), %rax
cmpq 0x10(%r14), %rax
jne 0xd8e1
movq %r14, %rdi
callq 0xd000
cmpl $-0x1, %eax
jne 0xd8ef
jmp 0xd90f
testb $0x2, 0x44(%r14)
je 0xd8ef
cmpb $0xa, -0x1(%r15)
je 0xd8d2
movb (%r15), %al
incq %r15
testb %al, %al
jne 0xd8b5
testb $0x4, 0x44(%r14)
je 0xd90d
movq %r14, %rdi
callq 0xd000
cmpl $-0x1, %eax
je 0xd90f
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xd0a4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /DevSolar[P]pdclib/functions/stdio/fputs.c |
PDCLIB_getstream | int _PDCLIB_getstream( struct _PDCLIB_file_t * stream )
{
struct _PDCLIB_file_t * previous;
if ( ! _PDCLIB_isstream( stream, &previous ) )
{
*_PDCLIB_errno_func() = _PDCLIB_EBADF;
return EOF;
}
if ( previous != NULL )
{
previous->next = stream->next;
}
else
{
_PDCLIB_filelist = stream->next;
}
return 0;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0xd98c
testl %eax, %eax
je 0xd966
movq 0x8(%rsp), %rcx
movq 0x78(%rbx), %rax
testq %rcx, %rcx
je 0xd978
movq %rax, 0x78(%rcx)
jmp 0xd982
callq 0xbdbc
movl $0x9, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xd984
leaq 0x8759(%rip), %rcx # 0x160d8
movq %rax, (%rcx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_getstream.c |
lest::passing::passing(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | passing( location where_, text expr_, text decomposition_, bool zen )
: success( "passed", where_, expr_ + (zen ? "":" for " + decomposition_) ) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x70f1(%rip), %rsi # 0xc155
leaq 0x70f0(%rip), %rdx # 0xc15b
leaq 0x20(%rsp), %rdi
callq 0x496e
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x80(%rsp), %rdi
callq 0x5648
movl 0x20(%r12), %eax
movl %eax, 0xa0(%rsp)
testb %bpl, %bpl
je 0x50ca
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x76eb(%rip), %rdx # 0xc7a6
leaq 0x40(%rsp), %rdi
movq %rdx, %rsi
callq 0x496e
jmp 0x50de
leaq 0x707c(%rip), %rsi # 0xc14d
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x5872
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3220
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5119
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x5120
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x765e(%rip), %rdx # 0xc7a6
leaq 0x60(%rsp), %rdi
movq %rdx, %rsi
callq 0x496e
leaq 0x20(%rsp), %rsi
leaq 0x80(%rsp), %rdx
movq %rsp, %rcx
leaq 0x60(%rsp), %r8
movq %rbx, %rdi
callq 0x58f4
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x5181
callq 0x31b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x518f
callq 0x31b0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51a2
callq 0x31b0
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x51b4
callq 0x31b0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x51c8
callq 0x31b0
leaq 0xbaa1(%rip), %rax # 0x10c70
movq %rax, (%rbx)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x51fb
callq 0x31b0
jmp 0x51fb
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x520e
callq 0x31b0
jmp 0x520e
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5226
callq 0x31b0
jmp 0x5226
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x523d
callq 0x31b0
jmp 0x523d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5251
callq 0x31b0
movq %rbx, %rdi
callq 0x3340
nop
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::env::context[abi:cxx11]() | text context() { return testing + sections(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5a80
movq 0x20(%r14), %rcx
movq 0x28(%r14), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3220
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x52aa
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x52b0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52da
callq 0x31b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52fd
callq 0x31b0
movq %rbx, %rdi
callq 0x3340
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::inform(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline void inform( location where, text expr )
{
try
{
throw;
}
catch( message const & )
{
throw;
}
catch( std::exception const & e )
{
throw unexpected{ where, expr, with_message( e.what() ) }; \
}
catch(...)
{
throw unexpected{ where, expr, "of unknown type" }; \
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %r15
callq 0x32a0
jmp 0x5538
movq %rdx, %r13
movq %rax, %rdi
cmpl $0x3, %r13d
jne 0x5341
callq 0x30f0
callq 0x32a0
jmp 0x5538
callq 0x30f0
movq %rax, %r12
movl $0x78, %edi
callq 0x3110
movq %rax, %rbx
cmpl $0x2, %r13d
jne 0x541b
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x5648
movl 0x20(%r15), %eax
movl %eax, 0x68(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x5648
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
leaq 0xf8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x30e0
leaq 0x6dc9(%rip), %rsi # 0xc191
leaq 0xd8(%rsp), %rdi
leaq 0xf8(%rsp), %rdx
callq 0x5872
leaq 0x6dba(%rip), %rsi # 0xc19e
leaq 0xd8(%rsp), %rdi
callq 0x3360
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x54cb
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x54d8
leaq 0xc0(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0xb0(%rsp), %rdi
callq 0x5648
movl 0x20(%r15), %eax
movl %eax, 0xd0(%rsp)
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x90(%rsp), %rdi
callq 0x5648
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x6ce0(%rip), %rsi # 0xc160
leaq 0x6ce8(%rip), %rdx # 0xc16f
leaq 0x70(%rsp), %rdi
callq 0x496e
movb $0x1, %bpl
leaq 0xb0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
callq 0x5ba6
xorl %ebp, %ebp
leaq 0xb826(%rip), %rsi # 0x10ce0
leaq 0x9c7(%rip), %rdx # 0x5e88
movq %rbx, %rdi
callq 0x3320
jmp 0x5538
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5506
callq 0x31b0
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x5ba6
xorl %ebp, %ebp
leaq 0xb7b7(%rip), %rsi # 0x10ce0
leaq 0x958(%rip), %rdx # 0x5e88
movq %rbx, %rdi
callq 0x3320
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x556d
callq 0x31b0
jmp 0x556d
movq %rax, %r14
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x556a
callq 0x31b0
jmp 0x556a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x108(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55b9
callq 0x31b0
jmp 0x55b9
movq %rax, %r14
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x559f
callq 0x31b0
jmp 0x559f
movq %rax, %r14
movb $0x1, %bpl
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x55d0
callq 0x31b0
jmp 0x55d0
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55ea
callq 0x31b0
jmp 0x55ea
movq %rax, %r14
movb $0x1, %bpl
movq 0xb0(%rsp), %rdi
cmpq %r12, %rdi
je 0x5601
callq 0x31b0
jmp 0x5601
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x561b
callq 0x31b0
jmp 0x561b
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x560e
movq %rbx, %rdi
callq 0x3170
callq 0x3310
jmp 0x5637
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5628
movq %rbx, %rdi
callq 0x3170
callq 0x3310
jmp 0x5637
movq %rax, %r14
callq 0x3310
movq %r14, %rdi
callq 0x3340
movq %rax, %rdi
callq 0x4962
nop
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::success::success(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | success( text kind_, location where_, text expr_, text note_ = "" )
: message( kind_, where_, expr_, note_ ) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x5648
leaq 0x70(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x5648
movl 0x20(%r12), %eax
movl %eax, 0x80(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x5648
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x5648
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
callq 0x5732
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x59bd
callq 0x31b0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x59cc
callq 0x31b0
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x59db
callq 0x31b0
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x59ea
callq 0x31b0
leaq 0xb2d7(%rip), %rax # 0x10cc8
movq %rax, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5a1c
callq 0x31b0
jmp 0x5a1c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5a30
callq 0x31b0
jmp 0x5a30
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5a44
callq 0x31b0
jmp 0x5a44
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x5a53
callq 0x31b0
movq %rbx, %rdi
callq 0x3340
nop
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::unexpected::unexpected(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | unexpected( location where_, text expr_, text note_ = "" )
: message{ "failed: got unexpected exception", where_, expr_, note_ } {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x659d(%rip), %rsi # 0xc170
leaq 0x65b6(%rip), %rdx # 0xc190
leaq 0x40(%rsp), %rdi
callq 0x496e
leaq 0x70(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x5648
movl 0x20(%r12), %eax
movl %eax, 0x80(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x5648
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x5648
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
callq 0x5732
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5c70
callq 0x31b0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5c7f
callq 0x31b0
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5c8e
callq 0x31b0
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x5c9d
callq 0x31b0
leaq 0xb064(%rip), %rax # 0x10d08
movq %rax, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5ccf
callq 0x31b0
jmp 0x5ccf
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5ce3
callq 0x31b0
jmp 0x5ce3
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5cf7
callq 0x31b0
jmp 0x5cf7
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x5d06
callq 0x31b0
movq %rbx, %rdi
callq 0x3340
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::expected::expected(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | expected( location where_, text expr_, text excpt_ = "" )
: message{ "failed: didn't get exception", where_, expr_, excpt_ } {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x6468(%rip), %rsi # 0xc1b5
leaq 0x647d(%rip), %rdx # 0xc1d1
leaq 0x40(%rsp), %rdi
callq 0x496e
leaq 0x70(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x5648
movl 0x20(%r12), %eax
movl %eax, 0x80(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x5648
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x5648
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
callq 0x5732
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5dea
callq 0x31b0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5df9
callq 0x31b0
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5e08
callq 0x31b0
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x5e17
callq 0x31b0
leaq 0xaf6a(%rip), %rax # 0x10d88
movq %rax, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5e49
callq 0x31b0
jmp 0x5e49
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5e5d
callq 0x31b0
jmp 0x5e5d
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5e71
callq 0x31b0
jmp 0x5e71
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x5e80
callq 0x31b0
movq %rbx, %rdi
callq 0x3340
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::split_arguments(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>) | inline auto split_arguments( texts args ) -> std::tuple<options, texts>
{
options option; texts in;
bool in_options = true;
for ( auto & arg : args )
{
if ( in_options )
{
text opt, val;
std::tie( opt, val ) = split_option( arg );
if ( opt[0] != '-' ) { in_options = false; }
else if ( opt == "--" ) { in_options = false; continue; }
else if ( opt == "-h" || "--help" == opt ) { option.help = true; continue; }
else if ( opt == "-a" || "--abort" == opt ) { option.abort = true; continue; }
else if ( opt == "-c" || "--count" == opt ) { option.count = true; continue; }
else if ( opt == "-g" || "--list-tags" == opt ) { option.tags = true; continue; }
else if ( opt == "-l" || "--list-tests" == opt ) { option.list = true; continue; }
else if ( opt == "-t" || "--time" == opt ) { option.time = true; continue; }
else if ( opt == "-p" || "--pass" == opt ) { option.pass = true; continue; }
else if ( opt == "-z" || "--pass-zen" == opt ) { option.zen = true; continue; }
else if ( opt == "-v" || "--verbose" == opt ) { option.verbose = true; continue; }
else if ( "--version" == opt ) { option.version = true; continue; }
else if ( opt == "--order" && "declared" == val ) { /* by definition */ ; continue; }
else if ( opt == "--order" && "lexical" == val ) { option.lexical = true; continue; }
else if ( opt == "--order" && "random" == val ) { option.random = true; continue; }
else if ( opt == "--random-seed" ) { option.seed = seed ( "--random-seed", val ); continue; }
else if ( opt == "--repeat" ) { option.repeat = repeat( "--repeat" , val ); continue; }
else throw std::runtime_error( "unrecognised option '" + arg + "' (try option --help)" );
}
in.push_back( arg );
}
option.pass = option.pass || option.zen;
return std::make_tuple( option, in );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
movq $0x0, 0xc0(%rsp)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x6d57
movq %rbx, 0xd0(%rsp)
leaq 0x1a8(%rsp), %rbp
movl $0x1, 0xc(%rsp)
movb $0x1, %r13b
leaq 0x198(%rsp), %rbx
leaq 0x118(%rsp), %r12
movl $0x0, %eax
movq %rax, 0x40(%rsp)
movl $0x0, %eax
movq %rax, 0x38(%rsp)
movl $0x0, %eax
movq %rax, 0x30(%rsp)
movl $0x0, %eax
movq %rax, 0x20(%rsp)
movl $0x0, %eax
movq %rax, 0x28(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0xa8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x98(%rsp)
movq $0x0, 0xa0(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x18(%rsp)
testb $0x1, %r13b
je 0x6c28
leaq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x80(%rsp)
movb %cl, 0x88(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %rcx, 0x60(%rsp)
movb %cl, 0x68(%rsp)
movq %rbp, 0x198(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5648
movq %r12, %rdi
movq %rbx, %rsi
callq 0x827f
leaq 0x78(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x3250
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x3250
movq 0x138(%rsp), %rdi
leaq 0x148(%rsp), %rax
cmpq %rax, %rdi
je 0x682f
callq 0x31b0
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x6849
callq 0x31b0
movq 0x198(%rsp), %rdi
movq %rbp, %rbx
cmpq %rbp, %rdi
je 0x685e
callq 0x31b0
movq 0x78(%rsp), %rax
movb (%rax), %bpl
cmpb $0x2d, %bpl
jne 0x6b91
leaq 0x78(%rsp), %r12
movq %r12, %rdi
leaq 0x595b(%rip), %rsi # 0xc1da
callq 0x3090
testl %eax, %eax
je 0x6b91
movq %r12, %rdi
leaq 0x5947(%rip), %rsi # 0xc1dd
callq 0x3090
testl %eax, %eax
je 0x6b96
movq %r12, %rdi
leaq 0x5933(%rip), %rsi # 0xc1e0
callq 0x3090
testl %eax, %eax
je 0x6b96
movq %r12, %rdi
leaq 0x5923(%rip), %rsi # 0xc1e7
callq 0x3090
testl %eax, %eax
je 0x6b9f
movq %r12, %rdi
leaq 0x590f(%rip), %rsi # 0xc1ea
callq 0x3090
testl %eax, %eax
je 0x6b9f
movq %r12, %rdi
leaq 0x5900(%rip), %rsi # 0xc1f2
callq 0x3090
testl %eax, %eax
je 0x6ba8
movq %r12, %rdi
leaq 0x58ec(%rip), %rsi # 0xc1f5
callq 0x3090
testl %eax, %eax
je 0x6ba8
movq %r12, %rdi
leaq 0x58dd(%rip), %rsi # 0xc1fd
callq 0x3090
testl %eax, %eax
je 0x6bb1
movq %r12, %rdi
leaq 0x58c9(%rip), %rsi # 0xc200
callq 0x3090
testl %eax, %eax
je 0x6bb1
movq %r12, %rdi
leaq 0x58be(%rip), %rsi # 0xc20c
callq 0x3090
testl %eax, %eax
je 0x6bba
movq %r12, %rdi
leaq 0x58aa(%rip), %rsi # 0xc20f
callq 0x3090
testl %eax, %eax
je 0x6bba
movq %r12, %rdi
leaq 0x58a0(%rip), %rsi # 0xc21c
callq 0x3090
testl %eax, %eax
je 0x6bc3
movq %r12, %rdi
leaq 0x588c(%rip), %rsi # 0xc21f
callq 0x3090
testl %eax, %eax
je 0x6bc3
movq %r12, %rdi
leaq 0x587c(%rip), %rsi # 0xc226
callq 0x3090
testl %eax, %eax
je 0x6bcc
movq %r12, %rdi
leaq 0x5868(%rip), %rsi # 0xc229
callq 0x3090
testl %eax, %eax
je 0x6bcc
movq %r12, %rdi
leaq 0x5858(%rip), %rsi # 0xc230
callq 0x3090
testl %eax, %eax
je 0x6bd5
movq %r12, %rdi
leaq 0x5844(%rip), %rsi # 0xc233
callq 0x3090
testl %eax, %eax
je 0x6bd5
movq %r12, %rdi
leaq 0x5838(%rip), %rsi # 0xc23e
callq 0x3090
testl %eax, %eax
je 0x6bdd
movq %r12, %rdi
leaq 0x5824(%rip), %rsi # 0xc241
callq 0x3090
testl %eax, %eax
je 0x6bdd
movq %r12, %rdi
leaq 0x5817(%rip), %rsi # 0xc24b
callq 0x3090
testl %eax, %eax
je 0x6c4a
movq %r12, %rdi
leaq 0x580a(%rip), %r12 # 0xc255
movq %r12, %rsi
callq 0x3090
testl %eax, %eax
jne 0x6a70
leaq 0x58(%rsp), %rdi
leaq 0x57fa(%rip), %rsi # 0xc25d
callq 0x3090
testl %eax, %eax
je 0x6be4
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x3090
testl %eax, %eax
jne 0x6a9a
leaq 0x58(%rsp), %rdi
leaq 0x57d9(%rip), %rsi # 0xc266
callq 0x3090
testl %eax, %eax
je 0x6d00
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x3090
testl %eax, %eax
jne 0x6ac4
leaq 0x58(%rsp), %rdi
leaq 0x57b7(%rip), %rsi # 0xc26e
callq 0x3090
testl %eax, %eax
je 0x6d0f
leaq 0x78(%rsp), %r12
movq %r12, %rdi
leaq 0x57a2(%rip), %rsi # 0xc275
callq 0x3090
testl %eax, %eax
je 0x6c56
movq %r12, %rdi
leaq 0x5799(%rip), %r12 # 0xc283
movq %r12, %rsi
callq 0x3090
testl %eax, %eax
jne 0x6e45
leaq 0xe8(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0xd8(%rsp), %rdi
movq %r12, %rsi
leaq 0x576f(%rip), %rdx # 0xc28b
callq 0x496e
leaq 0x168(%rsp), %rax
movq %rax, 0x158(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
addq %rsi, %rdx
leaq 0x158(%rsp), %r12
movq %r12, %rdi
callq 0x5648
leaq 0xd8(%rsp), %rdi
movq %r12, %rsi
callq 0x875c
movl %eax, 0xc(%rsp)
movq 0x158(%rsp), %rdi
leaq 0x168(%rsp), %rax
cmpq %rax, %rdi
je 0x6b7c
callq 0x31b0
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
jmp 0x6ced
xorl %r13d, %r13d
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x40(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x38(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x30(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x28(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x20(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x18(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x48(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, (%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x6bf8
callq 0x31b0
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x6c0f
callq 0x31b0
cmpb $0x2d, %bpl
movq %rbx, %rbp
leaq 0x198(%rsp), %rbx
leaq 0x118(%rsp), %r12
je 0x6c38
leaq 0xb0(%rsp), %rdi
movq %r14, %rsi
callq 0x8958
addq $0x20, %r14
cmpq %r15, %r14
jne 0x6796
jmp 0x6d1e
movb $0x1, %al
movq %rax, 0xa8(%rsp)
jmp 0x6be4
leaq 0x108(%rsp), %rax
movq %rax, 0xf8(%rsp)
leaq 0xf8(%rsp), %rdi
leaq 0x5600(%rip), %rsi # 0xc275
leaq 0x5606(%rip), %rdx # 0xc282
callq 0x496e
leaq 0x188(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
addq %rsi, %rdx
leaq 0x178(%rsp), %r12
movq %r12, %rdi
callq 0x5648
leaq 0xf8(%rsp), %rdi
movq %r12, %rsi
callq 0x844f
movq %rax, 0x50(%rsp)
movq 0x178(%rsp), %rdi
leaq 0x188(%rsp), %rax
cmpq %rax, %rdi
je 0x6cdd
callq 0x31b0
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x6be4
callq 0x31b0
jmp 0x6be4
movb $0x1, %al
movq %rax, 0xa0(%rsp)
jmp 0x6be4
movb $0x1, %al
movq %rax, 0x98(%rsp)
jmp 0x6be4
movzbl (%rsp), %eax
testb $0x1, 0x48(%rsp)
movl $0x1, %r14d
cmovel %eax, %r14d
movl 0xc(%rsp), %ebp
movq 0xa8(%rsp), %r15
movq 0xd0(%rsp), %rbx
movq 0x98(%rsp), %r12
movq 0xa0(%rsp), %r13
jmp 0x6db8
movl $0x1, %ebp
movq $0x0, 0x18(%rsp)
xorl %r14d, %r14d
movq $0x0, (%rsp)
xorl %r13d, %r13d
xorl %r12d, %r12d
movq $0x0, 0x10(%rsp)
xorl %r15d, %r15d
movq $0x0, 0x50(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x702c
movq 0x40(%rsp), %rax
movb %al, 0x18(%rbx)
movq 0x38(%rsp), %rax
movb %al, 0x19(%rbx)
movq 0x30(%rsp), %rax
movb %al, 0x1a(%rbx)
movq 0x20(%rsp), %rax
movb %al, 0x1b(%rbx)
movq 0x28(%rsp), %rax
movb %al, 0x1c(%rbx)
movq 0x18(%rsp), %rax
movb %al, 0x1d(%rbx)
movb %r14b, 0x1e(%rbx)
movq (%rsp), %rax
movb %al, 0x1f(%rbx)
movb %r13b, 0x20(%rbx)
movb %r12b, 0x21(%rbx)
movq 0x10(%rsp), %rax
movb %al, 0x22(%rbx)
movb %r15b, 0x23(%rbx)
movl %ebp, 0x24(%rbx)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rbx)
leaq 0xb0(%rsp), %rdi
callq 0x6642
movq %rbx, %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3110
movq %rax, %r12
leaq 0x5433(%rip), %rsi # 0xc28c
leaq 0x1b8(%rsp), %rdi
movq %r14, %rdx
callq 0x5872
leaq 0x5432(%rip), %rsi # 0xc2a2
leaq 0x1b8(%rsp), %rdi
callq 0x3360
leaq 0x128(%rsp), %rcx
movq %rcx, 0x118(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x6eac
movups (%rcx), %xmm0
leaq 0x128(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x6ebf
movq %rdx, 0x118(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x128(%rsp)
movq 0x8(%rax), %rdx
leaq 0x118(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r12, %rdi
callq 0x3300
xorl %ebp, %ebp
movq 0xa0fe(%rip), %rsi # 0x10ff0
movq 0xa0c7(%rip), %rdx # 0x10fc0
movq %r12, %rdi
callq 0x3320
movq %rax, %rbx
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x6f26
callq 0x31b0
jmp 0x6f26
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x1c8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f44
callq 0x31b0
jmp 0x6f44
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6fe7
movq %r12, %rdi
callq 0x3170
jmp 0x6fe7
movq %rax, %rbx
movq 0x178(%rsp), %rdi
leaq 0x188(%rsp), %rax
cmpq %rax, %rdi
je 0x6f7c
callq 0x31b0
jmp 0x6f7c
movq %rax, %rbx
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
jmp 0x6fc2
jmp 0x6fcd
movq %rax, %rbx
movq 0x158(%rsp), %rdi
leaq 0x168(%rsp), %rax
cmpq %rax, %rdi
je 0x6fb2
callq 0x31b0
jmp 0x6fb2
movq %rax, %rbx
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
jne 0x6fe2
jmp 0x6fe7
jmp 0x6fcd
jmp 0x7014
movq %rax, %rbx
jmp 0x6fe7
movq %rax, %rbx
movq 0x198(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6fe7
callq 0x31b0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x6ffb
callq 0x31b0
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x7017
callq 0x31b0
jmp 0x7017
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6642
movq %rbx, %rdi
callq 0x3340
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::times&& lest::for_test<lest::times>(std::vector<lest::test, std::allocator<lest::test>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, lest::times&&, int) | Action && for_test( tests specification, texts in, Action && perform, int n = 1 )
{
for ( int i = 0; indefinite( n ) || i < n; ++i )
{
for ( auto & testing : specification )
{
if ( select( testing.name, in ) )
if ( abort( perform( testing ) ) )
return std::move( perform );
}
}
return std::move( perform );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
cmpl $-0x1, %ecx
setne %al
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
setle %cl
testb %cl, %al
jne 0x7add
xorl %edx, %edx
leaq 0x30(%rsp), %rbx
leaq 0x90(%rsp), %r15
leaq 0x50(%rsp), %r13
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %r12
sete %r14b
je 0x7aba
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5648
movq %r15, %rdi
movq 0x20(%rsp), %rsi
callq 0x702c
movq %rbx, %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9d1e
movl %eax, %ebx
movq %r15, %rdi
callq 0x6642
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x7a20
callq 0x31b0
testb %bl, %bl
je 0x7aa3
leaq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rbx
movq %r13, %rdi
callq 0x5648
leaq 0x20(%r12), %rsi
leaq 0x70(%rsp), %rdi
callq 0xa6e6
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xaf30
cmpl $0x0, 0x64(%rax)
setg %bl
andb 0x11(%rax), %bl
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x7a87
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x7a9b
callq 0x31b0
testb %bl, %bl
je 0x7aa3
xorl %eax, %eax
jmp 0x7aa5
movb $0x1, %al
testb %al, %al
movq %rbp, %rbx
je 0x7aba
addq $0x40, %r12
cmpq 0x28(%rsp), %r12
jmp 0x79bf
testb $0x1, %r14b
movl 0xc(%rsp), %edx
je 0x7add
movl 0x8(%rsp), %ecx
cmpl $-0x1, %ecx
setne %al
incl %edx
cmpl %ecx, %edx
setge %cl
testb %cl, %al
je 0x79a7
movq 0x10(%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x4962
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x488e
jmp 0x7b43
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
jmp 0x7b39
movq %rax, %rbx
jmp 0x7b2f
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x6642
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x7b43
callq 0x31b0
movq %rbx, %rdi
callq 0x3340
nop
| /martinmoene[P]lest/include/lest/lest.hpp |
lest::times::~times() | ~times()
{
os << "Elapsed time: " << std::setprecision(1) << total.elapsed_seconds() << " s\n";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x4cbf(%rip), %rsi # 0xc8e8
movl $0xe, %edx
movq %r14, %rdi
callq 0x3230
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x1, 0x8(%r14,%rax)
callq 0x3050
subq 0x68(%rbx), %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
cvtsi2sd %rdx, %xmm0
mulsd 0x4391(%rip), %xmm0 # 0xc008
movq %r14, %rdi
callq 0x32f0
leaq 0x4c71(%rip), %rsi # 0xc8f7
movl $0x3, %edx
movq %rax, %rdi
callq 0x3230
leaq 0x48(%rbx), %rdi
callq 0x6642
movq 0x28(%rbx), %rdi
addq $0x38, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x7cb5
popq %rbx
popq %r14
jmp 0x31b0
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4962
| /martinmoene[P]lest/include/lest/lest.hpp |
lpo::program_options<int, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::has_opt(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 | bool
has_opt(const std::string & name, const std::string & short_name) const
{
return std::any_of(std::cbegin(m_check_list), std::cend(m_check_list), [&](const auto & n) {
return (name == n.first || (!short_name.empty() && short_name == n.second));
});
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %r14
addq $0x48, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpq %rbx, %r14
je 0xf659
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf66a
testb %al, %al
jne 0xf659
movq %r14, %rdi
callq 0x3280
movq %rax, %r14
cmpq %rbx, %rax
jne 0xf637
movq %rbx, %r14
cmpq %rbx, %r14
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /kenavolic[P]boost_light/lpo.h |
parse_tags | static int parse_tags(y4m_input *y4m_ctx, FILE *file) {
char tag[256];
char end; // Character denoting the end of the tag, ' ' or '\n'.
// Set Y4M tags to defaults, updating them as processing occurs. Mandatory
// fields are marked with -1 and will be checked after the tags are parsed.
y4m_ctx->pic_w = -1;
y4m_ctx->pic_h = -1;
y4m_ctx->fps_n = -1; // Also serves as marker for fps_d
y4m_ctx->par_n = 0;
y4m_ctx->par_d = 0;
y4m_ctx->interlace = '?';
y4m_ctx->color_range = AOM_CR_STUDIO_RANGE;
snprintf(y4m_ctx->chroma_type, sizeof(y4m_ctx->chroma_type), "420");
// Find one tag at a time.
do {
if (!copy_tag(tag, sizeof(tag), &end, file)) {
return 0;
}
// y4m_parse_tags returns 0 on success.
if (y4m_parse_tags(y4m_ctx, tag)) {
return 0;
}
} while (end != '\n');
// Check the mandatory fields.
if (y4m_ctx->pic_w == -1) {
fprintf(stderr, "Width field missing\n");
return 0;
}
if (y4m_ctx->pic_h == -1) {
fprintf(stderr, "Height field missing\n");
return 0;
}
if (y4m_ctx->fps_n == -1) {
fprintf(stderr, "FPS field missing\n");
return 0;
}
return 1;
} | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq 0x118(%rsp), %rax
movl $0xffffffff, 0x4(%rax) # imm = 0xFFFFFFFF
movq 0x118(%rsp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
movq 0x118(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x118(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x118(%rsp), %rax
movb $0x3f, 0x18(%rax)
movq 0x118(%rsp), %rax
movl $0x0, 0x84(%rax)
movq 0x118(%rsp), %rdi
addq $0x2c, %rdi
movl $0x10, %esi
leaq 0xa5eaca(%rip), %rdx # 0xa81c61
movb $0x0, %al
callq 0x187c0
leaq 0x10(%rsp), %rdi
movq 0x110(%rsp), %rcx
movl $0x100, %esi # imm = 0x100
leaq 0xf(%rsp), %rdx
callq 0x28c10
cmpl $0x0, %eax
jne 0x231cf
movl $0x0, 0x124(%rsp)
jmp 0x232a5
movq 0x118(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x28d70
cmpl $0x0, %eax
je 0x231f6
movl $0x0, 0x124(%rsp)
jmp 0x232a5
jmp 0x231f8
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x2319e
movq 0x118(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x23234
movq 0xb7bdc2(%rip), %rax # 0xb9efd8
movq (%rax), %rdi
leaq 0xa5f064(%rip), %rsi # 0xa82284
movb $0x0, %al
callq 0x186f0
movl $0x0, 0x124(%rsp)
jmp 0x232a5
movq 0x118(%rsp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x23267
movq 0xb7bd8f(%rip), %rax # 0xb9efd8
movq (%rax), %rdi
leaq 0xa5f046(%rip), %rsi # 0xa82299
movb $0x0, %al
callq 0x186f0
movl $0x0, 0x124(%rsp)
jmp 0x232a5
movq 0x118(%rsp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x2329a
movq 0xb7bd5c(%rip), %rax # 0xb9efd8
movq (%rax), %rdi
leaq 0xa5f029(%rip), %rsi # 0xa822af
movb $0x0, %al
callq 0x186f0
movl $0x0, 0x124(%rsp)
jmp 0x232a5
movl $0x1, 0x124(%rsp)
movl 0x124(%rsp), %eax
addq $0x128, %rsp # imm = 0x128
retq
nopw %cs:(%rax,%rax)
| /m-ab-s[P]aom/common/y4minput.c |
y4m_convert_42xpaldv_42xjpeg | static void y4m_convert_42xpaldv_42xjpeg(y4m_input *_y4m, unsigned char *_dst,
unsigned char *_aux) {
unsigned char *tmp;
int c_w;
int c_h;
int c_sz;
int pli;
int y;
int x;
/*Skip past the luma data.*/
_dst += _y4m->pic_w * _y4m->pic_h;
/*Compute the size of each chroma plane.*/
c_w = (_y4m->pic_w + 1) / 2;
c_h = (_y4m->pic_h + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
c_sz = c_w * c_h;
tmp = _aux + 2 * c_sz;
for (pli = 1; pli < 3; pli++) {
/*First do the horizontal re-sampling.
This is the same as the mpeg2 case, except that after the horizontal
case, we need to apply a second vertical filter.*/
y4m_42xmpeg2_42xjpeg_helper(tmp, _aux, c_w, c_h);
_aux += c_sz;
switch (pli) {
case 1: {
/*Slide C_b up a quarter-pel.
This is the same filter used above, but in the other order.*/
for (x = 0; x < c_w; x++) {
for (y = 0; y < OC_MINI(c_h, 3); y++) {
_dst[y * c_w] = (unsigned char)OC_CLAMPI(
0,
(tmp[0] - 9 * tmp[OC_MAXI(y - 2, 0) * c_w] +
35 * tmp[OC_MAXI(y - 1, 0) * c_w] + 114 * tmp[y * c_w] -
17 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] +
4 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + 64) >>
7,
255);
}
for (; y < c_h - 2; y++) {
_dst[y * c_w] = (unsigned char)OC_CLAMPI(
0,
(tmp[(y - 3) * c_w] - 9 * tmp[(y - 2) * c_w] +
35 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w] -
17 * tmp[(y + 1) * c_w] + 4 * tmp[(y + 2) * c_w] + 64) >>
7,
255);
}
for (; y < c_h; y++) {
_dst[y * c_w] = (unsigned char)OC_CLAMPI(
0,
(tmp[(y - 3) * c_w] - 9 * tmp[(y - 2) * c_w] +
35 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w] -
17 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] +
4 * tmp[(c_h - 1) * c_w] + 64) >>
7,
255);
}
_dst++;
tmp++;
}
_dst += c_sz - c_w;
tmp -= c_w;
} break;
case 2: {
/*Slide C_r down a quarter-pel.
This is the same as the horizontal filter.*/
for (x = 0; x < c_w; x++) {
for (y = 0; y < OC_MINI(c_h, 2); y++) {
_dst[y * c_w] = (unsigned char)OC_CLAMPI(
0,
(4 * tmp[0] - 17 * tmp[OC_MAXI(y - 1, 0) * c_w] +
114 * tmp[y * c_w] + 35 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] -
9 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] +
tmp[OC_MINI(y + 3, c_h - 1) * c_w] + 64) >>
7,
255);
}
for (; y < c_h - 3; y++) {
_dst[y * c_w] = (unsigned char)OC_CLAMPI(
0,
(4 * tmp[(y - 2) * c_w] - 17 * tmp[(y - 1) * c_w] +
114 * tmp[y * c_w] + 35 * tmp[(y + 1) * c_w] -
9 * tmp[(y + 2) * c_w] + tmp[(y + 3) * c_w] + 64) >>
7,
255);
}
for (; y < c_h; y++) {
_dst[y * c_w] = (unsigned char)OC_CLAMPI(
0,
(4 * tmp[(y - 2) * c_w] - 17 * tmp[(y - 1) * c_w] +
114 * tmp[y * c_w] + 35 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] -
9 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + tmp[(c_h - 1) * c_w] +
64) >>
7,
255);
}
_dst++;
tmp++;
}
} break;
}
/*For actual interlaced material, this would have to be done separately on
each field, and the shift amounts would be different.
C_r moves down 1/8, C_b up 3/8 in the top field, and C_r moves down 3/8,
C_b up 1/8 in the bottom field.
The corresponding filters would be:
Down 1/8 (reverse order for up): [3 -11 125 15 -4 0]/128
Down 3/8 (reverse order for up): [4 -19 98 56 -13 2]/128*/
}
} | subq $0x388, %rsp # imm = 0x388
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq %rdx, 0x370(%rsp)
movq 0x380(%rsp), %rax
movl (%rax), %ecx
movq 0x380(%rsp), %rax
imull 0x4(%rax), %ecx
movq 0x378(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x378(%rsp)
movq 0x380(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x364(%rsp)
movq 0x380(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x380(%rsp), %rcx
addl 0x24(%rcx), %eax
subl $0x1, %eax
movq 0x380(%rsp), %rcx
cltd
idivl 0x24(%rcx)
movl %eax, 0x360(%rsp)
movl 0x364(%rsp), %eax
imull 0x360(%rsp), %eax
movl %eax, 0x35c(%rsp)
movq 0x370(%rsp), %rax
movl 0x35c(%rsp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x368(%rsp)
movl $0x1, 0x358(%rsp)
cmpl $0x3, 0x358(%rsp)
jge 0x25c37
movq 0x368(%rsp), %rdi
movq 0x370(%rsp), %rsi
movl 0x364(%rsp), %edx
movl 0x360(%rsp), %ecx
callq 0x290d0
movslq 0x35c(%rsp), %rcx
movq 0x370(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x370(%rsp)
movl 0x358(%rsp), %eax
movl %eax, 0x34c(%rsp)
subl $0x1, %eax
je 0x23419
jmp 0x23404
movl 0x34c(%rsp), %eax
subl $0x2, %eax
je 0x247bd
jmp 0x25c1f
movl $0x0, 0x350(%rsp)
movl 0x350(%rsp), %eax
cmpl 0x364(%rsp), %eax
jge 0x24772
movl $0x0, 0x354(%rsp)
movl 0x354(%rsp), %eax
movl %eax, 0x348(%rsp)
cmpl $0x3, 0x360(%rsp)
jle 0x23469
movl $0x3, %eax
movl %eax, 0x344(%rsp)
jmp 0x23477
movl 0x360(%rsp), %eax
movl %eax, 0x344(%rsp)
movl 0x348(%rsp), %eax
movl 0x344(%rsp), %ecx
cmpl %ecx, %eax
jge 0x23d4b
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x334(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x338(%rsp)
movl 0x354(%rsp), %eax
subl $0x2, %eax
cmpl $0x0, %eax
jge 0x234c9
xorl %eax, %eax
movl %eax, 0x330(%rsp)
jmp 0x234da
movl 0x354(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x330(%rsp)
movl 0x334(%rsp), %eax
movq 0x338(%rsp), %rcx
movl 0x330(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x324(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x328(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x23535
xorl %eax, %eax
movl %eax, 0x320(%rsp)
jmp 0x23546
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x320(%rsp)
movl 0x324(%rsp), %eax
movq 0x328(%rsp), %rcx
movl 0x320(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x314(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x318(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x235d5
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x310(%rsp)
jmp 0x235e6
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x310(%rsp)
movl 0x314(%rsp), %eax
movq 0x318(%rsp), %rcx
movl 0x310(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x304(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x308(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x23652
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x300(%rsp)
jmp 0x23663
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x300(%rsp)
movl 0x304(%rsp), %eax
movq 0x308(%rsp), %rcx
movl 0x300(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x236ab
movl $0xff, %eax
movl %eax, 0x2fc(%rsp)
jmp 0x238b8
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x2ec(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x2f0(%rsp)
movl 0x354(%rsp), %eax
subl $0x2, %eax
cmpl $0x0, %eax
jge 0x236e7
xorl %eax, %eax
movl %eax, 0x2e8(%rsp)
jmp 0x236f8
movl 0x354(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x2e8(%rsp)
movl 0x2ec(%rsp), %eax
movq 0x2f0(%rsp), %rcx
movl 0x2e8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x2dc(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x2e0(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x23753
xorl %eax, %eax
movl %eax, 0x2d8(%rsp)
jmp 0x23764
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x2d8(%rsp)
movl 0x2dc(%rsp), %eax
movq 0x2e0(%rsp), %rcx
movl 0x2d8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x2cc(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x237f3
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x2c8(%rsp)
jmp 0x23804
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c8(%rsp)
movl 0x2cc(%rsp), %eax
movq 0x2d0(%rsp), %rcx
movl 0x2c8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x2bc(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x2c0(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x23870
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x2b8(%rsp)
jmp 0x23881
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x2b8(%rsp)
movl 0x2bc(%rsp), %eax
movq 0x2c0(%rsp), %rcx
movl 0x2b8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x2fc(%rsp)
movl 0x2fc(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x23d04
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x2ac(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movl 0x354(%rsp), %eax
subl $0x2, %eax
cmpl $0x0, %eax
jge 0x23905
xorl %eax, %eax
movl %eax, 0x2a8(%rsp)
jmp 0x23916
movl 0x354(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x2a8(%rsp)
movl 0x2ac(%rsp), %eax
movq 0x2b0(%rsp), %rcx
movl 0x2a8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x29c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x2a0(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x23971
xorl %eax, %eax
movl %eax, 0x298(%rsp)
jmp 0x23982
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x298(%rsp)
movl 0x29c(%rsp), %eax
movq 0x2a0(%rsp), %rcx
movl 0x298(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x28c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x290(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x23a11
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x288(%rsp)
jmp 0x23a22
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x288(%rsp)
movl 0x28c(%rsp), %eax
movq 0x290(%rsp), %rcx
movl 0x288(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x27c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x280(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x23a8e
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x278(%rsp)
jmp 0x23a9f
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x278(%rsp)
movl 0x27c(%rsp), %eax
movq 0x280(%rsp), %rcx
movl 0x278(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x23ae7
movl $0xff, %eax
movl %eax, 0x274(%rsp)
jmp 0x23cf4
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x264(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x268(%rsp)
movl 0x354(%rsp), %eax
subl $0x2, %eax
cmpl $0x0, %eax
jge 0x23b23
xorl %eax, %eax
movl %eax, 0x260(%rsp)
jmp 0x23b34
movl 0x354(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x260(%rsp)
movl 0x264(%rsp), %eax
movq 0x268(%rsp), %rcx
movl 0x260(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x254(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x258(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x23b8f
xorl %eax, %eax
movl %eax, 0x250(%rsp)
jmp 0x23ba0
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x250(%rsp)
movl 0x254(%rsp), %eax
movq 0x258(%rsp), %rcx
movl 0x250(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x244(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x248(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x23c2f
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x240(%rsp)
jmp 0x23c40
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x240(%rsp)
movl 0x244(%rsp), %eax
movq 0x248(%rsp), %rcx
movl 0x240(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x234(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x238(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x23cac
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x230(%rsp)
jmp 0x23cbd
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x230(%rsp)
movl 0x234(%rsp), %eax
movq 0x238(%rsp), %rcx
movl 0x230(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x274(%rsp)
movl 0x274(%rsp), %eax
movl %eax, 0x22c(%rsp)
jmp 0x23d0f
xorl %eax, %eax
movl %eax, 0x22c(%rsp)
jmp 0x23d0f
movl 0x22c(%rsp), %eax
movb %al, %dl
movq 0x378(%rsp), %rax
movl 0x354(%rsp), %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x354(%rsp)
jmp 0x23443
jmp 0x23d4d
movl 0x354(%rsp), %eax
movl 0x360(%rsp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x24194
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x23e60
movl $0xff, %eax
movl %eax, 0x228(%rsp)
jmp 0x23f49
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x228(%rsp)
movl 0x228(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x2414d
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x24054
movl $0xff, %eax
movl %eax, 0x224(%rsp)
jmp 0x2413d
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x224(%rsp)
movl 0x224(%rsp), %eax
movl %eax, 0x220(%rsp)
jmp 0x24158
xorl %eax, %eax
movl %eax, 0x220(%rsp)
jmp 0x24158
movl 0x220(%rsp), %eax
movb %al, %dl
movq 0x378(%rsp), %rax
movl 0x354(%rsp), %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x354(%rsp)
jmp 0x23d4d
jmp 0x24196
movl 0x354(%rsp), %eax
cmpl 0x360(%rsp), %eax
jge 0x24734
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x214(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x218(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2427c
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x210(%rsp)
jmp 0x2428d
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x210(%rsp)
movl 0x214(%rsp), %eax
movq 0x218(%rsp), %rcx
movl 0x210(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x242fb
movl $0xff, %eax
movl %eax, 0x20c(%rsp)
jmp 0x2443b
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x1fc(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x200(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x243cd
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x1f8(%rsp)
jmp 0x243de
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1f8(%rsp)
movl 0x1fc(%rsp), %eax
movq 0x200(%rsp), %rcx
movl 0x1f8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x20c(%rsp)
movl 0x20c(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x246ed
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x1ec(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x1f0(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2451e
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x1e8(%rsp)
jmp 0x2452f
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1e8(%rsp)
movl 0x1ec(%rsp), %eax
movq 0x1f0(%rsp), %rcx
movl 0x1e8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x2459d
movl $0xff, %eax
movl %eax, 0x1e4(%rsp)
jmp 0x246dd
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x3, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x1d4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2466f
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x1d0(%rsp)
jmp 0x24680
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1d0(%rsp)
movl 0x1d4(%rsp), %eax
movq 0x1d8(%rsp), %rcx
movl 0x1d0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x1e4(%rsp)
movl 0x1e4(%rsp), %eax
movl %eax, 0x1cc(%rsp)
jmp 0x246f8
xorl %eax, %eax
movl %eax, 0x1cc(%rsp)
jmp 0x246f8
movl 0x1cc(%rsp), %eax
movb %al, %dl
movq 0x378(%rsp), %rax
movl 0x354(%rsp), %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x354(%rsp)
jmp 0x24196
movq 0x378(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x378(%rsp)
movq 0x368(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x368(%rsp)
movl 0x350(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x350(%rsp)
jmp 0x23424
movl 0x35c(%rsp), %ecx
subl 0x364(%rsp), %ecx
movq 0x378(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x378(%rsp)
movl 0x364(%rsp), %ecx
movq 0x368(%rsp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x368(%rsp)
jmp 0x25c1f
movl $0x0, 0x350(%rsp)
movl 0x350(%rsp), %eax
cmpl 0x364(%rsp), %eax
jge 0x25c1d
movl $0x0, 0x354(%rsp)
movl 0x354(%rsp), %eax
movl %eax, 0x1c8(%rsp)
cmpl $0x2, 0x360(%rsp)
jle 0x2480d
movl $0x2, %eax
movl %eax, 0x1c4(%rsp)
jmp 0x2481b
movl 0x360(%rsp), %eax
movl %eax, 0x1c4(%rsp)
movl 0x1c8(%rsp), %eax
movl 0x1c4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x25133
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movl %eax, 0x1b4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x1b8(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x24870
xorl %eax, %eax
movl %eax, 0x1b0(%rsp)
jmp 0x24881
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x1b0(%rsp)
movl 0x1b4(%rsp), %eax
movq 0x1b8(%rsp), %rcx
movl 0x1b0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x1a4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x1a8(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24910
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x1a0(%rsp)
jmp 0x24921
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1a0(%rsp)
movl 0x1a4(%rsp), %eax
movq 0x1a8(%rsp), %rcx
movl 0x1a0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x194(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x198(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2498d
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x190(%rsp)
jmp 0x2499e
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x190(%rsp)
movl 0x194(%rsp), %eax
movq 0x198(%rsp), %rcx
movl 0x190(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x184(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x188(%rsp)
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24a0a
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x180(%rsp)
jmp 0x24a1b
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x180(%rsp)
movl 0x184(%rsp), %eax
movq 0x188(%rsp), %rcx
movl 0x180(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x24a60
movl $0xff, %eax
movl %eax, 0x17c(%rsp)
jmp 0x24c7e
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movl %eax, 0x16c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x170(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x24a9f
xorl %eax, %eax
movl %eax, 0x168(%rsp)
jmp 0x24ab0
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x168(%rsp)
movl 0x16c(%rsp), %eax
movq 0x170(%rsp), %rcx
movl 0x168(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x15c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x160(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24b3f
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x158(%rsp)
jmp 0x24b50
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x158(%rsp)
movl 0x15c(%rsp), %eax
movq 0x160(%rsp), %rcx
movl 0x158(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x14c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x150(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24bbc
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x148(%rsp)
jmp 0x24bcd
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x148(%rsp)
movl 0x14c(%rsp), %eax
movq 0x150(%rsp), %rcx
movl 0x148(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0x13c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x140(%rsp)
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24c39
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x138(%rsp)
jmp 0x24c4a
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x138(%rsp)
movl 0x13c(%rsp), %eax
movq 0x140(%rsp), %rcx
movl 0x138(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x17c(%rsp)
movl 0x17c(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x250ec
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movl %eax, 0x12c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x130(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x24cce
xorl %eax, %eax
movl %eax, 0x128(%rsp)
jmp 0x24cdf
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x128(%rsp)
movl 0x12c(%rsp), %eax
movq 0x130(%rsp), %rcx
movl 0x128(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x11c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x120(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24d6e
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x118(%rsp)
jmp 0x24d7f
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x118(%rsp)
movl 0x11c(%rsp), %eax
movq 0x120(%rsp), %rcx
movl 0x118(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x10c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x110(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24deb
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x108(%rsp)
jmp 0x24dfc
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x108(%rsp)
movl 0x10c(%rsp), %eax
movq 0x110(%rsp), %rcx
movl 0x108(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0xfc(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x100(%rsp)
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24e68
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xf8(%rsp)
jmp 0x24e79
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl %eax, 0xf8(%rsp)
movl 0xfc(%rsp), %eax
movq 0x100(%rsp), %rcx
movl 0xf8(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x24ebe
movl $0xff, %eax
movl %eax, 0xf4(%rsp)
jmp 0x250dc
movq 0x368(%rsp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movl %eax, 0xe4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0xe8(%rsp)
movl 0x354(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x24efd
xorl %eax, %eax
movl %eax, 0xe0(%rsp)
jmp 0x24f0e
movl 0x354(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xe0(%rsp)
movl 0xe4(%rsp), %eax
movq 0xe8(%rsp), %rcx
movl 0xe0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0xd4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0xd8(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x24f9d
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xd0(%rsp)
jmp 0x24fae
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd0(%rsp)
movl 0xd4(%rsp), %eax
movq 0xd8(%rsp), %rcx
movl 0xd0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0xc4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x2501a
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc0(%rsp)
jmp 0x2502b
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %eax
movq 0xc8(%rsp), %rcx
movl 0xc0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movl %eax, 0xb4(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0xb8(%rsp)
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x25097
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xb0(%rsp)
jmp 0x250a8
movl 0x354(%rsp), %eax
addl $0x3, %eax
movl %eax, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
movq 0xb8(%rsp), %rcx
movl 0xb0(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0xf4(%rsp)
movl 0xf4(%rsp), %eax
movl %eax, 0xac(%rsp)
jmp 0x250f7
xorl %eax, %eax
movl %eax, 0xac(%rsp)
jmp 0x250f7
movl 0xac(%rsp), %eax
movb %al, %dl
movq 0x378(%rsp), %rax
movl 0x354(%rsp), %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x354(%rsp)
jmp 0x247e7
jmp 0x25135
movl 0x354(%rsp), %eax
movl 0x360(%rsp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x2557c
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x3, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x25248
movl $0xff, %eax
movl %eax, 0xa8(%rsp)
jmp 0x25331
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x3, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0xa8(%rsp)
movl 0xa8(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x25535
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x3, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x2543c
movl $0xff, %eax
movl %eax, 0xa4(%rsp)
jmp 0x25525
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x2, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
addl $0x3, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
movl %eax, 0xa0(%rsp)
jmp 0x25540
xorl %eax, %eax
movl %eax, 0xa0(%rsp)
jmp 0x25540
movl 0xa0(%rsp), %eax
movb %al, %dl
movq 0x378(%rsp), %rax
movl 0x354(%rsp), %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x354(%rsp)
jmp 0x25135
jmp 0x2557e
movl 0x354(%rsp), %eax
cmpl 0x360(%rsp), %eax
jge 0x25bdf
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x94(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x98(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x25641
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x25652
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
movl 0x94(%rsp), %eax
movq 0x98(%rsp), %rcx
movl 0x90(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x84(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x88(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x256be
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x256cf
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x80(%rsp)
movl 0x84(%rsp), %eax
movq 0x88(%rsp), %rcx
movl 0x80(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x25737
movl $0xff, %eax
movl %eax, 0x7c(%rsp)
jmp 0x258a1
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x6c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x70(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x257dd
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x257eb
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
movl 0x6c(%rsp), %eax
movq 0x70(%rsp), %rcx
movl 0x68(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x5c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x25845
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x25853
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x58(%rsp)
movl 0x5c(%rsp), %eax
movq 0x60(%rsp), %rcx
movl 0x58(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x25b9e
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x4c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x25955
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x25963
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %eax
movq 0x50(%rsp), %rcx
movl 0x48(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x3c(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x259bd
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x259cb
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
movq 0x40(%rsp), %rcx
movl 0x38(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
cmpl $0xff, %eax
jle 0x25a2a
movl $0xff, %eax
movl %eax, 0x34(%rsp)
jmp 0x25b94
movq 0x368(%rsp), %rax
movl 0x354(%rsp), %ecx
subl $0x2, %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x11, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x354(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x72, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x24(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x25ad0
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x25ade
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
movl 0x20(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x23, %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x368(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl 0x360(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x25b38
movl 0x360(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x25b46
movl 0x354(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
movl 0x10(%rsp), %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
imull $0x9, %ecx, %ecx
subl %ecx, %eax
movq 0x368(%rsp), %rcx
movl 0x360(%rsp), %edx
subl $0x1, %edx
imull 0x364(%rsp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x40, %eax
sarl $0x7, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x25ba6
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x25ba6
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x378(%rsp), %rax
movl 0x354(%rsp), %ecx
imull 0x364(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x354(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x354(%rsp)
jmp 0x2557e
movq 0x378(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x378(%rsp)
movq 0x368(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x368(%rsp)
movl 0x350(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x350(%rsp)
jmp 0x247c8
jmp 0x25c1f
jmp 0x25c21
movl 0x358(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x358(%rsp)
jmp 0x233a3
addq $0x388, %rsp # imm = 0x388
retq
nop
| /m-ab-s[P]aom/common/y4minput.c |
I420ToAR30Matrix | LIBYUV_API
int I420ToAR30Matrix(const uint8_t* src_y,
int src_stride_y,
const uint8_t* src_u,
int src_stride_u,
const uint8_t* src_v,
int src_stride_v,
uint8_t* dst_ar30,
int dst_stride_ar30,
const struct YuvConstants* yuvconstants,
int width,
int height) {
int y;
void (*I422ToAR30Row)(const uint8_t* y_buf, const uint8_t* u_buf,
const uint8_t* v_buf, uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants, int width) =
I422ToAR30Row_C;
if (!src_y || !src_u || !src_v || !dst_ar30 || width <= 0 || height == 0) {
return -1;
}
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_ar30 = dst_ar30 + (height - 1) * dst_stride_ar30;
dst_stride_ar30 = -dst_stride_ar30;
}
#if defined(HAS_I422TOAR30ROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
I422ToAR30Row = I422ToAR30Row_Any_SSSE3;
if (IS_ALIGNED(width, 8)) {
I422ToAR30Row = I422ToAR30Row_SSSE3;
}
}
#endif
#if defined(HAS_I422TOAR30ROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
I422ToAR30Row = I422ToAR30Row_Any_AVX2;
if (IS_ALIGNED(width, 16)) {
I422ToAR30Row = I422ToAR30Row_AVX2;
}
}
#endif
for (y = 0; y < height; ++y) {
I422ToAR30Row(src_y, src_u, src_v, dst_ar30, yuvconstants, width);
dst_ar30 += dst_stride_ar30;
src_y += src_stride_y;
if (y & 1) {
src_u += src_stride_u;
src_v += src_stride_v;
}
}
return 0;
} | subq $0x48, %rsp
movl 0x70(%rsp), %eax
movl 0x68(%rsp), %eax
movq 0x60(%rsp), %rax
movl 0x58(%rsp), %eax
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
leaq 0x19c23(%rip), %rax # 0x547c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x3abd0
cmpq $0x0, 0x28(%rsp)
je 0x3abd0
cmpq $0x0, 0x18(%rsp)
je 0x3abd0
cmpq $0x0, 0x50(%rsp)
je 0x3abd0
cmpl $0x0, 0x68(%rsp)
jle 0x3abd0
cmpl $0x0, 0x70(%rsp)
jne 0x3abdd
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x3ad35
cmpl $0x0, 0x70(%rsp)
jge 0x3ac14
xorl %eax, %eax
subl 0x70(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x50(%rsp), %rax
movl 0x70(%rsp), %ecx
subl $0x1, %ecx
imull 0x58(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
xorl %eax, %eax
subl 0x58(%rsp), %eax
movl %eax, 0x58(%rsp)
movl $0x40, %edi
callq 0x33be0
cmpl $0x0, %eax
je 0x3ac4c
leaq 0x8c86(%rip), %rax # 0x438b0
movq %rax, 0x8(%rsp)
movslq 0x68(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x3ac4a
leaq 0x222eb(%rip), %rax # 0x5cf30
movq %rax, 0x8(%rsp)
jmp 0x3ac4c
movl $0x400, %edi # imm = 0x400
callq 0x33be0
cmpl $0x0, %eax
je 0x3ac84
leaq 0x8e6e(%rip), %rax # 0x43ad0
movq %rax, 0x8(%rsp)
movslq 0x68(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x3ac82
leaq 0x230e3(%rip), %rax # 0x5dd60
movq %rax, 0x8(%rsp)
jmp 0x3ac84
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x70(%rsp), %eax
jge 0x3ad2d
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %r8
movl 0x68(%rsp), %r9d
callq *%rax
movl 0x58(%rsp), %ecx
movq 0x50(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movl 0x34(%rsp), %ecx
movq 0x38(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movl 0x10(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3ad1b
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x3ad1d
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3ac8c
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
| /m-ab-s[P]aom/third_party/libyuv/source/convert_argb.cc |
YUY2ToNV12 | LIBYUV_API
int YUY2ToNV12(const uint8_t* src_yuy2,
int src_stride_yuy2,
uint8_t* dst_y,
int dst_stride_y,
uint8_t* dst_uv,
int dst_stride_uv,
int width,
int height) {
int y;
int halfwidth = (width + 1) >> 1;
void (*SplitUVRow)(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v,
int width) = SplitUVRow_C;
void (*InterpolateRow)(uint8_t * dst_ptr, const uint8_t* src_ptr,
ptrdiff_t src_stride, int dst_width,
int source_y_fraction) = InterpolateRow_C;
if (!src_yuy2 || !dst_y || !dst_uv || width <= 0 || height == 0) {
return -1;
}
// Negative height means invert the image.
if (height < 0) {
height = -height;
src_yuy2 = src_yuy2 + (height - 1) * src_stride_yuy2;
src_stride_yuy2 = -src_stride_yuy2;
}
#if defined(HAS_SPLITUVROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
SplitUVRow = SplitUVRow_Any_SSE2;
if (IS_ALIGNED(width, 16)) {
SplitUVRow = SplitUVRow_SSE2;
}
}
#endif
#if defined(HAS_SPLITUVROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
SplitUVRow = SplitUVRow_Any_AVX2;
if (IS_ALIGNED(width, 32)) {
SplitUVRow = SplitUVRow_AVX2;
}
}
#endif
#if defined(HAS_SPLITUVROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
SplitUVRow = SplitUVRow_Any_NEON;
if (IS_ALIGNED(width, 16)) {
SplitUVRow = SplitUVRow_NEON;
}
}
#endif
#if defined(HAS_SPLITUVROW_MMI)
if (TestCpuFlag(kCpuHasMMI)) {
SplitUVRow = SplitUVRow_Any_MMI;
if (IS_ALIGNED(width, 8)) {
SplitUVRow = SplitUVRow_MMI;
}
}
#endif
#if defined(HAS_SPLITUVROW_MSA)
if (TestCpuFlag(kCpuHasMSA)) {
SplitUVRow = SplitUVRow_Any_MSA;
if (IS_ALIGNED(width, 32)) {
SplitUVRow = SplitUVRow_MSA;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
InterpolateRow = InterpolateRow_Any_SSSE3;
if (IS_ALIGNED(width, 16)) {
InterpolateRow = InterpolateRow_SSSE3;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_AVX2)
if (TestCpuFlag(kCpuHasAVX2)) {
InterpolateRow = InterpolateRow_Any_AVX2;
if (IS_ALIGNED(width, 32)) {
InterpolateRow = InterpolateRow_AVX2;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
InterpolateRow = InterpolateRow_Any_NEON;
if (IS_ALIGNED(width, 16)) {
InterpolateRow = InterpolateRow_NEON;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_MMI)
if (TestCpuFlag(kCpuHasMMI)) {
InterpolateRow = InterpolateRow_Any_MMI;
if (IS_ALIGNED(width, 8)) {
InterpolateRow = InterpolateRow_MMI;
}
}
#endif
#if defined(HAS_INTERPOLATEROW_MSA)
if (TestCpuFlag(kCpuHasMSA)) {
InterpolateRow = InterpolateRow_Any_MSA;
if (IS_ALIGNED(width, 32)) {
InterpolateRow = InterpolateRow_MSA;
}
}
#endif
{
int awidth = halfwidth * 2;
// row of y and 2 rows of uv
align_buffer_64(rows, awidth * 3);
for (y = 0; y < height - 1; y += 2) {
// Split Y from UV.
SplitUVRow(src_yuy2, rows, rows + awidth, awidth);
memcpy(dst_y, rows, width);
SplitUVRow(src_yuy2 + src_stride_yuy2, rows, rows + awidth * 2, awidth);
memcpy(dst_y + dst_stride_y, rows, width);
InterpolateRow(dst_uv, rows + awidth, awidth, awidth, 128);
src_yuy2 += src_stride_yuy2 * 2;
dst_y += dst_stride_y * 2;
dst_uv += dst_stride_uv;
}
if (height & 1) {
// Split Y from UV.
SplitUVRow(src_yuy2, rows, dst_uv, awidth);
memcpy(dst_y, rows, width);
}
free_aligned_buffer_64(rows);
}
return 0;
} | subq $0x68, %rsp
movl 0x78(%rsp), %eax
movl 0x70(%rsp), %eax
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movl %r9d, 0x34(%rsp)
movl 0x70(%rsp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, 0x2c(%rsp)
leaq 0x14614(%rip), %rax # 0x56630
movq %rax, 0x20(%rsp)
leaq 0x15c28(%rip), %rax # 0x57c50
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x42053
cmpq $0x0, 0x48(%rsp)
je 0x42053
cmpq $0x0, 0x38(%rsp)
je 0x42053
cmpl $0x0, 0x70(%rsp)
jle 0x42053
cmpl $0x0, 0x78(%rsp)
jne 0x42060
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x42305
cmpl $0x0, 0x78(%rsp)
jge 0x42097
xorl %eax, %eax
subl 0x78(%rsp), %eax
movl %eax, 0x78(%rsp)
movq 0x58(%rsp), %rax
movl 0x78(%rsp), %ecx
subl $0x1, %ecx
imull 0x54(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
xorl %eax, %eax
subl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movl $0x20, %edi
callq 0x3b630
cmpl $0x0, %eax
je 0x420cf
leaq 0xa873(%rip), %rax # 0x4c920
movq %rax, 0x20(%rsp)
movslq 0x70(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x420cd
leaq 0x1cd08(%rip), %rax # 0x5edd0
movq %rax, 0x20(%rsp)
jmp 0x420cf
movl $0x400, %edi # imm = 0x400
callq 0x3b630
cmpl $0x0, %eax
je 0x42107
leaq 0xa98b(%rip), %rax # 0x4ca70
movq %rax, 0x20(%rsp)
movslq 0x70(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0x42105
leaq 0x1cc40(%rip), %rax # 0x5ed40
movq %rax, 0x20(%rsp)
jmp 0x42107
movl $0x40, %edi
callq 0x3b630
cmpl $0x0, %eax
je 0x4213f
leaq 0x9f43(%rip), %rax # 0x4c060
movq %rax, 0x18(%rsp)
movslq 0x70(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x4213d
leaq 0x1f238(%rip), %rax # 0x61370
movq %rax, 0x18(%rsp)
jmp 0x4213f
movl $0x400, %edi # imm = 0x400
callq 0x3b630
cmpl $0x0, %eax
je 0x42177
leaq 0x9dbb(%rip), %rax # 0x4bf10
movq %rax, 0x18(%rsp)
movslq 0x70(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0x42175
leaq 0x1f320(%rip), %rax # 0x61490
movq %rax, 0x18(%rsp)
jmp 0x42177
movl 0x2c(%rsp), %eax
shll %eax
movl %eax, 0x14(%rsp)
imull $0x3, 0x14(%rsp), %eax
addl $0x3f, %eax
movslq %eax, %rdi
callq 0x18620
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x3f, %rax
andq $-0x40, %rax
movq %rax, (%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl 0x78(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x422b3
movq 0x20(%rsp), %rax
movq 0x58(%rsp), %rdi
movq (%rsp), %rsi
movq (%rsp), %rdx
movslq 0x14(%rsp), %rcx
addq %rcx, %rdx
movl 0x14(%rsp), %ecx
callq *%rax
movq 0x48(%rsp), %rdi
movq (%rsp), %rsi
movslq 0x70(%rsp), %rdx
callq 0x183b0
movq 0x20(%rsp), %rax
movq 0x58(%rsp), %rdi
movslq 0x54(%rsp), %rcx
addq %rcx, %rdi
movq (%rsp), %rsi
movq (%rsp), %rdx
movl 0x14(%rsp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rdx
movl 0x14(%rsp), %ecx
callq *%rax
movq 0x48(%rsp), %rdi
movslq 0x44(%rsp), %rax
addq %rax, %rdi
movq (%rsp), %rsi
movslq 0x70(%rsp), %rdx
callq 0x183b0
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rdi
movq (%rsp), %rsi
movslq 0x14(%rsp), %rcx
addq %rcx, %rsi
movslq 0x14(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl $0x80, %r8d
callq *%rax
movl 0x54(%rsp), %ecx
shll %ecx
movq 0x58(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movl 0x44(%rsp), %ecx
shll %ecx
movq 0x48(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movl 0x34(%rsp), %ecx
movq 0x38(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movl 0x30(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x30(%rsp)
jmp 0x421af
movl 0x78(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x422eb
movq 0x20(%rsp), %rax
movq 0x58(%rsp), %rdi
movq (%rsp), %rsi
movq 0x38(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq *%rax
movq 0x48(%rsp), %rdi
movq (%rsp), %rsi
movslq 0x70(%rsp), %rdx
callq 0x183b0
movq 0x8(%rsp), %rdi
callq 0x18570
movq $0x0, (%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
| /m-ab-s[P]aom/third_party/libyuv/source/planar_functions.cc |
SobelToPlaneRow_C | void SobelToPlaneRow_C(const uint8_t* src_sobelx,
const uint8_t* src_sobely,
uint8_t* dst_y,
int width) {
int i;
for (i = 0; i < width; ++i) {
int r = src_sobelx[i];
int b = src_sobely[i];
int s = clamp255(r + b);
dst_y[i] = (uint8_t)(s);
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x53d0e
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %edi
addl 0x10(%rsp), %edi
callq 0x4f930
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x53caf
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
J400ToARGBRow_C | void J400ToARGBRow_C(const uint8_t* src_y, uint8_t* dst_argb, int width) {
// Copy a Y to RGB.
int x;
for (x = 0; x < width; ++x) {
uint8_t y = src_y[0];
dst_argb[2] = dst_argb[1] = dst_argb[0] = y;
dst_argb[3] = 255u;
dst_argb += 4;
++src_y;
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x53e58
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
movb $-0x1, 0x3(%rax)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x53df6
retq
nopl (%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
libyuv::YuvPixel(unsigned char, unsigned char, unsigned char, unsigned char*, unsigned char*, unsigned char*, libyuv::YuvConstants const*) | static __inline void YuvPixel(uint8_t y,
uint8_t u,
uint8_t v,
uint8_t* b,
uint8_t* g,
uint8_t* r,
const struct YuvConstants* yuvconstants) {
#if defined(__aarch64__)
int ub = -yuvconstants->kUVToRB[0];
int ug = yuvconstants->kUVToG[0];
int vg = yuvconstants->kUVToG[1];
int vr = -yuvconstants->kUVToRB[1];
int bb = yuvconstants->kUVBiasBGR[0];
int bg = yuvconstants->kUVBiasBGR[1];
int br = yuvconstants->kUVBiasBGR[2];
int yg = yuvconstants->kYToRgb[1];
#elif defined(__arm__)
int ub = -yuvconstants->kUVToRB[0];
int ug = yuvconstants->kUVToG[0];
int vg = yuvconstants->kUVToG[4];
int vr = -yuvconstants->kUVToRB[4];
int bb = yuvconstants->kUVBiasBGR[0];
int bg = yuvconstants->kUVBiasBGR[1];
int br = yuvconstants->kUVBiasBGR[2];
int yg = yuvconstants->kYToRgb[1];
#else
int ub = yuvconstants->kUVToB[0];
int ug = yuvconstants->kUVToG[0];
int vg = yuvconstants->kUVToG[1];
int vr = yuvconstants->kUVToR[1];
int bb = yuvconstants->kUVBiasB[0];
int bg = yuvconstants->kUVBiasG[0];
int br = yuvconstants->kUVBiasR[0];
int yg = yuvconstants->kYToRgb[0];
#endif
uint32_t y1 = (uint32_t)(y * 0x0101 * yg) >> 16;
*b = Clamp((int32_t)(-(u * ub) + y1 + bb) >> 6);
*g = Clamp((int32_t)(-(u * ug + v * vg) + y1 + bg) >> 6);
*r = Clamp((int32_t)(-(v * vr) + y1 + br) >> 6);
} | subq $0x48, %rsp
movb %dl, %al
movb %sil, %dl
movb %dil, %sil
movq 0x50(%rsp), %rdi
movb %sil, 0x47(%rsp)
movb %dl, 0x46(%rsp)
movb %al, 0x45(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rax
movsbl 0x20(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movsbl 0x21(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x50(%rsp), %rax
movsbl 0x41(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movswl 0x60(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rax
movswl 0x80(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movswl 0xa0(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rax
movswl 0xc0(%rax), %eax
movl %eax, 0x8(%rsp)
movzbl 0x47(%rsp), %eax
imull $0x101, %eax, %eax # imm = 0x101
imull 0x8(%rsp), %eax
shrl $0x10, %eax
movl %eax, 0x4(%rsp)
movzbl 0x46(%rsp), %eax
imull 0x24(%rsp), %eax
xorl %edi, %edi
subl %eax, %edi
addl 0x4(%rsp), %edi
addl 0x14(%rsp), %edi
sarl $0x6, %edi
callq 0x53150
movb %al, %cl
movq 0x38(%rsp), %rax
movb %cl, (%rax)
movzbl 0x46(%rsp), %eax
imull 0x20(%rsp), %eax
movzbl 0x45(%rsp), %ecx
imull 0x1c(%rsp), %ecx
addl %ecx, %eax
xorl %edi, %edi
subl %eax, %edi
addl 0x4(%rsp), %edi
addl 0x10(%rsp), %edi
sarl $0x6, %edi
callq 0x53150
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, (%rax)
movzbl 0x45(%rsp), %eax
imull 0x18(%rsp), %eax
xorl %edi, %edi
subl %eax, %edi
addl 0x4(%rsp), %edi
addl 0xc(%rsp), %edi
sarl $0x6, %edi
callq 0x53150
movb %al, %cl
movq 0x28(%rsp), %rax
movb %cl, (%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToARGBRow_C | void I422ToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
rgb_buf + 6, yuvconstants);
rgb_buf[7] = 255;
src_y += 2;
src_u += 1;
src_v += 1;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x541aa
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x20(%rsp), %rax
movb (%rax), %dl
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq $0x1, %r8
movq 0x18(%rsp), %r9
addq $0x2, %r9
movq 0x10(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x18(%rsp), %rax
movb $-0x1, 0x3(%rax)
movq 0x30(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x20(%rsp), %rax
movb (%rax), %dl
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
movq 0x18(%rsp), %r8
addq $0x5, %r8
movq 0x18(%rsp), %r9
addq $0x6, %r9
movq 0x10(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x18(%rsp), %rax
movb $-0x1, 0x7(%rax)
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0x540aa
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x54206
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x20(%rsp), %rax
movb (%rax), %dl
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq $0x1, %r8
movq 0x18(%rsp), %r9
addq $0x2, %r9
movq 0x10(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x18(%rsp), %rax
movb $-0x1, 0x3(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I210ToARGBRow_C | void I210ToARGBRow_C(const uint16_t* src_y,
const uint16_t* src_u,
const uint16_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
YuvPixel10(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
rgb_buf + 6, yuvconstants);
rgb_buf[7] = 255;
src_y += 2;
src_u += 1;
src_v += 1;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel10(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54338
movq 0x30(%rsp), %rax
movw (%rax), %di
movq 0x28(%rsp), %rax
movw (%rax), %si
movq 0x20(%rsp), %rax
movw (%rax), %dx
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq $0x1, %r8
movq 0x18(%rsp), %r9
addq $0x2, %r9
movq 0x10(%rsp), %rax
movzwl %di, %edi
movzwl %si, %esi
movzwl %dx, %edx
movq %rax, (%rsp)
callq 0x543a0
movq 0x18(%rsp), %rax
movb $-0x1, 0x3(%rax)
movq 0x30(%rsp), %rax
movw 0x2(%rax), %di
movq 0x28(%rsp), %rax
movw (%rax), %si
movq 0x20(%rsp), %rax
movw (%rax), %dx
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
movq 0x18(%rsp), %r8
addq $0x5, %r8
movq 0x18(%rsp), %r9
addq $0x6, %r9
movq 0x10(%rsp), %rax
movzwl %di, %edi
movzwl %si, %esi
movzwl %dx, %edx
movq %rax, (%rsp)
callq 0x543a0
movq 0x18(%rsp), %rax
movb $-0x1, 0x7(%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0x5423a
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x54393
movq 0x30(%rsp), %rax
movw (%rax), %di
movq 0x28(%rsp), %rax
movw (%rax), %si
movq 0x20(%rsp), %rax
movw (%rax), %dx
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq $0x1, %r8
movq 0x18(%rsp), %r9
addq $0x2, %r9
movq 0x10(%rsp), %rax
movzwl %di, %edi
movzwl %si, %esi
movzwl %dx, %edx
movq %rax, (%rsp)
callq 0x543a0
movq 0x18(%rsp), %rax
movb $-0x1, 0x3(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I210ToAR30Row_C | void I210ToAR30Row_C(const uint16_t* src_y,
const uint16_t* src_u,
const uint16_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
int b;
int g;
int r;
for (x = 0; x < width - 1; x += 2) {
YuvPixel16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
StoreAR30(rgb_buf, b, g, r);
YuvPixel16(src_y[1], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
StoreAR30(rgb_buf + 4, b, g, r);
src_y += 2;
src_u += 1;
src_v += 1;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
StoreAR30(rgb_buf, b, g, r);
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54582
movq 0x40(%rsp), %rax
movw (%rax), %di
movq 0x38(%rsp), %rax
movw (%rax), %si
movq 0x30(%rsp), %rax
movw (%rax), %dx
movq 0x20(%rsp), %rax
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
movswl %di, %edi
movswl %si, %esi
movswl %dx, %edx
movq %rax, (%rsp)
callq 0x545f0
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x54730
movq 0x40(%rsp), %rax
movw 0x2(%rax), %di
movq 0x38(%rsp), %rax
movw (%rax), %si
movq 0x30(%rsp), %rax
movw (%rax), %dx
movq 0x20(%rsp), %rax
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
movswl %di, %edi
movswl %si, %esi
movswl %dx, %edx
movq %rax, (%rsp)
callq 0x545f0
movq 0x28(%rsp), %rdi
addq $0x4, %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x54730
movq 0x40(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0x18(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x18(%rsp)
jmp 0x5447a
movl 0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x545e2
movq 0x40(%rsp), %rax
movw (%rax), %di
movq 0x38(%rsp), %rax
movw (%rax), %si
movq 0x30(%rsp), %rax
movw (%rax), %dx
movq 0x20(%rsp), %rax
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
movswl %di, %edi
movswl %si, %esi
movswl %dx, %edx
movq %rax, (%rsp)
callq 0x545f0
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x54730
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
libyuv::StoreAR30(unsigned char*, int, int, int) | static void StoreAR30(uint8_t* rgb_buf, int b, int g, int r) {
uint32_t ar30;
b = b >> 4; // convert 10.6 to 10 bit.
g = g >> 4;
r = r >> 4;
b = Clamp10(b);
g = Clamp10(g);
r = Clamp10(r);
ar30 = b | ((uint32_t)g << 10) | ((uint32_t)r << 20) | 0xc0000000;
(*(uint32_t*)rgb_buf) = ar30;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movl 0xc(%rsp), %eax
sarl $0x4, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
sarl $0x4, %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
sarl $0x4, %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %edi
callq 0x5ab20
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %edi
callq 0x5ab20
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %edi
callq 0x5ab20
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
shll $0xa, %ecx
orl %ecx, %eax
movl 0x4(%rsp), %ecx
shll $0x14, %ecx
orl %ecx, %eax
orl $0xc0000000, %eax # imm = 0xC0000000
movl %eax, (%rsp)
movl (%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToAR30Row_C | void I422ToAR30Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
int b;
int g;
int r;
for (x = 0; x < width - 1; x += 2) {
YuvPixel8_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
StoreAR30(rgb_buf, b, g, r);
YuvPixel8_16(src_y[1], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
StoreAR30(rgb_buf + 4, b, g, r);
src_y += 2;
src_u += 1;
src_v += 1;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel8_16(src_y[0], src_u[0], src_v[0], &b, &g, &r, yuvconstants);
StoreAR30(rgb_buf, b, g, r);
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x548f4
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x54960
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x54730
movq 0x40(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x54960
movq 0x28(%rsp), %rdi
addq $0x4, %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x54730
movq 0x40(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0x18(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x18(%rsp)
jmp 0x547ea
movl 0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x54955
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0xc(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x54960
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x54730
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422AlphaToARGBRow_C | void I422AlphaToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
const uint8_t* src_a,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = src_a[0];
YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 4, rgb_buf + 5,
rgb_buf + 6, yuvconstants);
rgb_buf[7] = src_a[1];
src_y += 2;
src_u += 1;
src_v += 1;
src_a += 2;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = src_a[0];
}
} | subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x50(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54bc9
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x28(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x3(%rax)
movq 0x40(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
addq $0x4, %rcx
movq 0x20(%rsp), %r8
addq $0x5, %r8
movq 0x20(%rsp), %r9
addq $0x6, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x28(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x7(%rax)
movq 0x40(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x54aae
movl 0x50(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x54c2b
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x28(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x3(%rax)
addq $0x48, %rsp
retq
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToRGB24Row_C | void I422ToRGB24Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
YuvPixel(src_y[1], src_u[0], src_v[0], rgb_buf + 3, rgb_buf + 4,
rgb_buf + 5, yuvconstants);
src_y += 2;
src_u += 1;
src_v += 1;
rgb_buf += 6; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_u[0], src_v[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x54d48
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x20(%rsp), %rax
movb (%rax), %dl
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq $0x1, %r8
movq 0x18(%rsp), %r9
addq $0x2, %r9
movq 0x10(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x30(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x20(%rsp), %rax
movb (%rax), %dl
movq 0x18(%rsp), %rcx
addq $0x3, %rcx
movq 0x18(%rsp), %r8
addq $0x4, %r8
movq 0x18(%rsp), %r9
addq $0x5, %r9
movq 0x10(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x6, %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0x54c5a
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x54d9b
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x20(%rsp), %rax
movb (%rax), %dl
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq $0x1, %r8
movq 0x18(%rsp), %r9
addq $0x2, %r9
movq 0x10(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
addq $0x38, %rsp
retq
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToARGB1555Row_C | void I422ToARGB1555Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_argb1555,
const struct YuvConstants* yuvconstants,
int width) {
uint8_t b0;
uint8_t g0;
uint8_t r0;
uint8_t b1;
uint8_t g1;
uint8_t r1;
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
YuvPixel(src_y[1], src_u[0], src_v[0], &b1, &g1, &r1, yuvconstants);
b0 = b0 >> 3;
g0 = g0 >> 3;
r0 = r0 >> 3;
b1 = b1 >> 3;
g1 = g1 >> 3;
r1 = r1 >> 3;
*(uint32_t*)(dst_argb1555) = b0 | (g0 << 5) | (r0 << 10) | (b1 << 16) |
(g1 << 21) | (r1 << 26) | 0x80008000;
src_y += 2;
src_u += 1;
src_v += 1;
dst_argb1555 += 4; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
b0 = b0 >> 3;
g0 = g0 >> 3;
r0 = r0 >> 3;
*(uint16_t*)(dst_argb1555) = b0 | (g0 << 5) | (r0 << 10) | 0x8000;
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x55170
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x1b(%rsp), %rcx
leaq 0x1a(%rsp), %r8
leaq 0x19(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x40(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x18(%rsp), %rcx
leaq 0x17(%rsp), %r8
leaq 0x16(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movzbl 0x1b(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x1b(%rsp)
movzbl 0x1a(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x1a(%rsp)
movzbl 0x19(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x19(%rsp)
movzbl 0x18(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x18(%rsp)
movzbl 0x17(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x17(%rsp)
movzbl 0x16(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x16(%rsp)
movzbl 0x1b(%rsp), %ecx
movzbl 0x1a(%rsp), %eax
shll $0x5, %eax
orl %eax, %ecx
movzbl 0x19(%rsp), %eax
shll $0xa, %eax
orl %eax, %ecx
movzbl 0x18(%rsp), %eax
shll $0x10, %eax
orl %eax, %ecx
movzbl 0x17(%rsp), %eax
shll $0x15, %eax
orl %eax, %ecx
movzbl 0x16(%rsp), %eax
shll $0x1a, %eax
orl %eax, %ecx
orl $0x80008000, %ecx # imm = 0x80008000
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movl 0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
jmp 0x5500a
movl 0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5520c
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x1b(%rsp), %rcx
leaq 0x1a(%rsp), %r8
leaq 0x19(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movzbl 0x1b(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x1b(%rsp)
movzbl 0x1a(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x1a(%rsp)
movzbl 0x19(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x19(%rsp)
movzbl 0x1b(%rsp), %eax
movzbl 0x1a(%rsp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
movzbl 0x19(%rsp), %ecx
shll $0xa, %ecx
orl %ecx, %eax
orl $0x8000, %eax # imm = 0x8000
movw %ax, %cx
movq 0x28(%rsp), %rax
movw %cx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
I422ToRGB565Row_C | void I422ToRGB565Row_C(const uint8_t* src_y,
const uint8_t* src_u,
const uint8_t* src_v,
uint8_t* dst_rgb565,
const struct YuvConstants* yuvconstants,
int width) {
uint8_t b0;
uint8_t g0;
uint8_t r0;
uint8_t b1;
uint8_t g1;
uint8_t r1;
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
YuvPixel(src_y[1], src_u[0], src_v[0], &b1, &g1, &r1, yuvconstants);
b0 = b0 >> 3;
g0 = g0 >> 2;
r0 = r0 >> 3;
b1 = b1 >> 3;
g1 = g1 >> 2;
r1 = r1 >> 3;
*(uint32_t*)(dst_rgb565) =
b0 | (g0 << 5) | (r0 << 11) | (b1 << 16) | (g1 << 21) | (r1 << 27);
src_y += 2;
src_u += 1;
src_v += 1;
dst_rgb565 += 4; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_u[0], src_v[0], &b0, &g0, &r0, yuvconstants);
b0 = b0 >> 3;
g0 = g0 >> 2;
r0 = r0 >> 3;
*(uint16_t*)(dst_rgb565) = b0 | (g0 << 5) | (r0 << 11);
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x553aa
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x1b(%rsp), %rcx
leaq 0x1a(%rsp), %r8
leaq 0x19(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x40(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x18(%rsp), %rcx
leaq 0x17(%rsp), %r8
leaq 0x16(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movzbl 0x1b(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x1b(%rsp)
movzbl 0x1a(%rsp), %eax
sarl $0x2, %eax
movb %al, 0x1a(%rsp)
movzbl 0x19(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x19(%rsp)
movzbl 0x18(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x18(%rsp)
movzbl 0x17(%rsp), %eax
sarl $0x2, %eax
movb %al, 0x17(%rsp)
movzbl 0x16(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x16(%rsp)
movzbl 0x1b(%rsp), %ecx
movzbl 0x1a(%rsp), %eax
shll $0x5, %eax
orl %eax, %ecx
movzbl 0x19(%rsp), %eax
shll $0xb, %eax
orl %eax, %ecx
movzbl 0x18(%rsp), %eax
shll $0x10, %eax
orl %eax, %ecx
movzbl 0x17(%rsp), %eax
shll $0x15, %eax
orl %eax, %ecx
movzbl 0x16(%rsp), %eax
shll $0x1b, %eax
orl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movl 0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
jmp 0x5524a
movl 0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x55441
movq 0x40(%rsp), %rax
movb (%rax), %dil
movq 0x38(%rsp), %rax
movb (%rax), %sil
movq 0x30(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rax
leaq 0x1b(%rsp), %rcx
leaq 0x1a(%rsp), %r8
leaq 0x19(%rsp), %r9
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movzbl 0x1b(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x1b(%rsp)
movzbl 0x1a(%rsp), %eax
sarl $0x2, %eax
movb %al, 0x1a(%rsp)
movzbl 0x19(%rsp), %eax
sarl $0x3, %eax
movb %al, 0x19(%rsp)
movzbl 0x1b(%rsp), %eax
movzbl 0x1a(%rsp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
movzbl 0x19(%rsp), %ecx
shll $0xb, %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x28(%rsp), %rax
movw %cx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
NV12ToARGBRow_C | void NV12ToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_uv,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
YuvPixel(src_y[1], src_uv[0], src_uv[1], rgb_buf + 4, rgb_buf + 5,
rgb_buf + 6, yuvconstants);
rgb_buf[7] = 255;
src_y += 2;
src_uv += 2;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_uv[0], src_uv[1], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x55569
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x20(%rsp), %rax
movb $-0x1, 0x3(%rax)
movq 0x30(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %dl
movq 0x20(%rsp), %rcx
addq $0x4, %rcx
movq 0x20(%rsp), %r8
addq $0x5, %r8
movq 0x20(%rsp), %r9
addq $0x6, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x20(%rsp), %rax
movb $-0x1, 0x7(%rax)
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movl 0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
jmp 0x55475
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x555c6
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb (%rax), %sil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x20(%rsp), %rax
movb $-0x1, 0x3(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
NV21ToARGBRow_C | void NV21ToARGBRow_C(const uint8_t* src_y,
const uint8_t* src_vu,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
YuvPixel(src_y[1], src_vu[1], src_vu[0], rgb_buf + 4, rgb_buf + 5,
rgb_buf + 6, yuvconstants);
rgb_buf[7] = 255;
src_y += 2;
src_vu += 2;
rgb_buf += 8; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
rgb_buf[3] = 255;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x556e9
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
movq 0x28(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x20(%rsp), %rax
movb $-0x1, 0x3(%rax)
movq 0x30(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
movq 0x28(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
addq $0x4, %rcx
movq 0x20(%rsp), %r8
addq $0x5, %r8
movq 0x20(%rsp), %r9
addq $0x6, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x20(%rsp), %rax
movb $-0x1, 0x7(%rax)
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movl 0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
jmp 0x555f5
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x55746
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
movq 0x28(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x20(%rsp), %rax
movb $-0x1, 0x3(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
NV21ToRGB24Row_C | void NV21ToRGB24Row_C(const uint8_t* src_y,
const uint8_t* src_vu,
uint8_t* rgb_buf,
const struct YuvConstants* yuvconstants,
int width) {
int x;
for (x = 0; x < width - 1; x += 2) {
YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
YuvPixel(src_y[1], src_vu[1], src_vu[0], rgb_buf + 3, rgb_buf + 4,
rgb_buf + 5, yuvconstants);
src_y += 2;
src_vu += 2;
rgb_buf += 6; // Advance 2 pixels.
}
if (width & 1) {
YuvPixel(src_y[0], src_vu[1], src_vu[0], rgb_buf + 0, rgb_buf + 1,
rgb_buf + 2, yuvconstants);
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x559b7
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
movq 0x28(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x30(%rsp), %rax
movb 0x1(%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
movq 0x28(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
addq $0x3, %rcx
movq 0x20(%rsp), %r8
addq $0x4, %r8
movq 0x20(%rsp), %r9
addq $0x5, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
movq 0x30(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x6, %rax
movq %rax, 0x20(%rsp)
movl 0x10(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
jmp 0x558d5
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x55a0b
movq 0x30(%rsp), %rax
movb (%rax), %dil
movq 0x28(%rsp), %rax
movb 0x1(%rax), %sil
movq 0x28(%rsp), %rax
movb (%rax), %dl
movq 0x20(%rsp), %rcx
movq 0x20(%rsp), %r8
addq $0x1, %r8
movq 0x20(%rsp), %r9
addq $0x2, %r9
movq 0x18(%rsp), %rax
movzbl %dil, %edi
movzbl %sil, %esi
movzbl %dl, %edx
movq %rax, (%rsp)
callq 0x53f40
addq $0x38, %rsp
retq
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
MirrorRow_C | void MirrorRow_C(const uint8_t* src, uint8_t* dst, int width) {
int x;
src += width - 1;
for (x = 0; x < width - 1; x += 2) {
dst[x] = src[0];
dst[x + 1] = src[-1];
src -= 2;
}
if (width & 1) {
dst[width - 1] = src[0];
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x562f5
movq -0x8(%rsp), %rax
movb (%rax), %dl
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movb -0x1(%rax), %dl
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
addq $-0x2, %rax
movq %rax, -0x8(%rsp)
movl -0x18(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rsp)
jmp 0x5629d
movl -0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5631a
movq -0x8(%rsp), %rax
movb (%rax), %dl
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
retq
nopl (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_common.cc |
ARGBToYJRow_AVX2 | void ARGBToYJRow_AVX2(const uint8_t* src_argb, uint8_t* dst_y, int width) {
asm volatile(
"vbroadcastf128 %3,%%ymm4 \n"
"vbroadcastf128 %4,%%ymm5 \n"
"vmovdqu %5,%%ymm6 \n"
LABELALIGN RGBTOY_AVX2(ymm5)
: "+r"(src_argb), // %0
"+r"(dst_y), // %1
"+r"(width) // %2
: "m"(kARGBToYJ), // %3
"m"(kSub128), // %4
"m"(kPermdARGBToY_AVX) // %5
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
"xmm7");
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rdx
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %eax
vbroadcastf128 0xa2844b(%rip), %ymm4 # ymm4 = mem[0,1,0,1]
vbroadcastf128 0xa28422(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vmovdqu 0xa2845a(%rip), %ymm6 # 0xa84260
vmovdqu (%rdx), %ymm0
vmovdqu 0x20(%rdx), %ymm1
vmovdqu 0x40(%rdx), %ymm2
vmovdqu 0x60(%rdx), %ymm3
vpsubb %ymm5, %ymm0, %ymm0
vpsubb %ymm5, %ymm1, %ymm1
vpsubb %ymm5, %ymm2, %ymm2
vpsubb %ymm5, %ymm3, %ymm3
vpmaddubsw %ymm0, %ymm4, %ymm0
vpmaddubsw %ymm1, %ymm4, %ymm1
vpmaddubsw %ymm2, %ymm4, %ymm2
vpmaddubsw %ymm3, %ymm4, %ymm3
leaq 0x80(%rdx), %rdx
vphaddw %ymm1, %ymm0, %ymm0
vphaddw %ymm3, %ymm2, %ymm2
prefetcht0 0x500(%rdx)
vpaddw %ymm5, %ymm0, %ymm0
vpaddw %ymm5, %ymm2, %ymm2
vpsrlw $0x8, %ymm0, %ymm0
vpsrlw $0x8, %ymm2, %ymm2
vpackuswb %ymm2, %ymm0, %ymm0
vpermd %ymm0, %ymm6, %ymm0
vmovdqu %ymm0, (%rcx)
leaq 0x20(%rcx), %rcx
subl $0x20, %eax
jg 0x5be06
vzeroupper
movq %rdx, -0x8(%rsp)
movq %rcx, -0x10(%rsp)
movl %eax, -0x14(%rsp)
retq
nop
| /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
RGBAToYJRow_AVX2 | void RGBAToYJRow_AVX2(const uint8_t* src_rgba, uint8_t* dst_y, int width) {
asm volatile(
"vbroadcastf128 %3,%%ymm4 \n"
"vbroadcastf128 %4,%%ymm5 \n"
"vmovdqu %5,%%ymm6 \n"
LABELALIGN RGBTOY_AVX2(
ymm5) "vzeroupper \n"
: "+r"(src_rgba), // %0
"+r"(dst_y), // %1
"+r"(width) // %2
: "m"(kRGBAToYJ), // %3
"m"(kSub128), // %4
"m"(kPermdARGBToY_AVX) // %5
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6");
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rdx
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %eax
vbroadcastf128 0xa2839b(%rip), %ymm4 # ymm4 = mem[0,1,0,1]
vbroadcastf128 0xa28362(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vmovdqu 0xa2839a(%rip), %ymm6 # 0xa84260
vmovdqu (%rdx), %ymm0
vmovdqu 0x20(%rdx), %ymm1
vmovdqu 0x40(%rdx), %ymm2
vmovdqu 0x60(%rdx), %ymm3
vpsubb %ymm5, %ymm0, %ymm0
vpsubb %ymm5, %ymm1, %ymm1
vpsubb %ymm5, %ymm2, %ymm2
vpsubb %ymm5, %ymm3, %ymm3
vpmaddubsw %ymm0, %ymm4, %ymm0
vpmaddubsw %ymm1, %ymm4, %ymm1
vpmaddubsw %ymm2, %ymm4, %ymm2
vpmaddubsw %ymm3, %ymm4, %ymm3
leaq 0x80(%rdx), %rdx
vphaddw %ymm1, %ymm0, %ymm0
vphaddw %ymm3, %ymm2, %ymm2
prefetcht0 0x500(%rdx)
vpaddw %ymm5, %ymm0, %ymm0
vpaddw %ymm5, %ymm2, %ymm2
vpsrlw $0x8, %ymm0, %ymm0
vpsrlw $0x8, %ymm2, %ymm2
vpackuswb %ymm2, %ymm0, %ymm0
vpermd %ymm0, %ymm6, %ymm0
vmovdqu %ymm0, (%rcx)
leaq 0x20(%rcx), %rcx
subl $0x20, %eax
jg 0x5bec6
vzeroupper
vzeroupper
movq %rdx, -0x8(%rsp)
movq %rcx, -0x10(%rsp)
movl %eax, -0x14(%rsp)
retq
nopw %cs:(%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ARGBToUVRow_SSSE3 | void ARGBToUVRow_SSSE3(const uint8_t* src_argb0,
int src_stride_argb,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"movdqa %5,%%xmm3 \n"
"movdqa %6,%%xmm4 \n"
"movdqa %7,%%xmm5 \n"
"sub %1,%2 \n"
LABELALIGN
"1: \n"
"movdqu (%0),%%xmm0 \n"
"movdqu 0x00(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm0 \n"
"movdqu 0x10(%0),%%xmm1 \n"
"movdqu 0x10(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm1 \n"
"movdqu 0x20(%0),%%xmm2 \n"
"movdqu 0x20(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm2 \n"
"movdqu 0x30(%0),%%xmm6 \n"
"movdqu 0x30(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm6 \n"
"lea 0x40(%0),%0 \n"
"movdqa %%xmm0,%%xmm7 \n"
"shufps $0x88,%%xmm1,%%xmm0 \n"
"shufps $0xdd,%%xmm1,%%xmm7 \n"
"pavgb %%xmm7,%%xmm0 \n"
"movdqa %%xmm2,%%xmm7 \n"
"shufps $0x88,%%xmm6,%%xmm2 \n"
"shufps $0xdd,%%xmm6,%%xmm7 \n"
"pavgb %%xmm7,%%xmm2 \n"
"movdqa %%xmm0,%%xmm1 \n"
"movdqa %%xmm2,%%xmm6 \n"
"pmaddubsw %%xmm4,%%xmm0 \n"
"pmaddubsw %%xmm4,%%xmm2 \n"
"pmaddubsw %%xmm3,%%xmm1 \n"
"pmaddubsw %%xmm3,%%xmm6 \n"
"phaddw %%xmm2,%%xmm0 \n"
"phaddw %%xmm6,%%xmm1 \n"
"psraw $0x8,%%xmm0 \n"
"psraw $0x8,%%xmm1 \n"
"packsswb %%xmm1,%%xmm0 \n"
"paddb %%xmm5,%%xmm0 \n"
"movlps %%xmm0,(%1) \n"
"movhps %%xmm0,0x00(%1,%2,1) \n"
"lea 0x8(%1),%1 \n"
"sub $0x10,%3 \n"
"jg 1b \n"
: "+r"(src_argb0), // %0
"+r"(dst_u), // %1
"+r"(dst_v), // %2
"+rm"(width) // %3
: "r"((intptr_t)(src_stride_argb)), // %4
"m"(kARGBToV), // %5
"m"(kARGBToU), // %6
"m"(kAddUV128) // %7
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
movdqa 0xa282f8(%rip), %xmm3 # 0xa84290
movdqa 0xa28300(%rip), %xmm4 # 0xa842a0
movdqa 0xa28308(%rip), %xmm5 # 0xa842b0
subq %rcx, %rax
movdqu (%rdx), %xmm0
movdqu (%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm0
movdqu 0x10(%rdx), %xmm1
movdqu 0x10(%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm1
movdqu 0x20(%rdx), %xmm2
movdqu 0x20(%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm2
movdqu 0x30(%rdx), %xmm6
movdqu 0x30(%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm6
leaq 0x40(%rdx), %rdx
movdqa %xmm0, %xmm7
shufps $0x88, %xmm1, %xmm0 # xmm0 = xmm0[0,2],xmm1[0,2]
shufps $0xdd, %xmm1, %xmm7 # xmm7 = xmm7[1,3],xmm1[1,3]
pavgb %xmm7, %xmm0
movdqa %xmm2, %xmm7
shufps $0x88, %xmm6, %xmm2 # xmm2 = xmm2[0,2],xmm6[0,2]
shufps $0xdd, %xmm6, %xmm7 # xmm7 = xmm7[1,3],xmm6[1,3]
pavgb %xmm7, %xmm2
movdqa %xmm0, %xmm1
movdqa %xmm2, %xmm6
pmaddubsw %xmm4, %xmm0
pmaddubsw %xmm4, %xmm2
pmaddubsw %xmm3, %xmm1
pmaddubsw %xmm3, %xmm6
phaddw %xmm2, %xmm0
phaddw %xmm6, %xmm1
psraw $0x8, %xmm0
psraw $0x8, %xmm1
packsswb %xmm1, %xmm0
paddb %xmm5, %xmm0
movlps %xmm0, (%rcx)
movhps %xmm0, (%rcx,%rax)
leaq 0x8(%rcx), %rcx
subl $0x10, %esi
jg 0x5bfab
movl %esi, -0x24(%rsp)
movq %rdx, -0x8(%rsp)
movq %rcx, -0x18(%rsp)
movq %rax, -0x20(%rsp)
retq
nopl (%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ABGRToUVRow_AVX2 | void ABGRToUVRow_AVX2(const uint8_t* src_abgr0,
int src_stride_abgr,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"vbroadcastf128 %5,%%ymm5 \n"
"vbroadcastf128 %6,%%ymm6 \n"
"vbroadcastf128 %7,%%ymm7 \n"
"sub %1,%2 \n"
LABELALIGN
"1: \n"
"vmovdqu (%0),%%ymm0 \n"
"vmovdqu 0x20(%0),%%ymm1 \n"
"vmovdqu 0x40(%0),%%ymm2 \n"
"vmovdqu 0x60(%0),%%ymm3 \n"
"vpavgb 0x00(%0,%4,1),%%ymm0,%%ymm0 \n"
"vpavgb 0x20(%0,%4,1),%%ymm1,%%ymm1 \n"
"vpavgb 0x40(%0,%4,1),%%ymm2,%%ymm2 \n"
"vpavgb 0x60(%0,%4,1),%%ymm3,%%ymm3 \n"
"lea 0x80(%0),%0 \n"
"vshufps $0x88,%%ymm1,%%ymm0,%%ymm4 \n"
"vshufps $0xdd,%%ymm1,%%ymm0,%%ymm0 \n"
"vpavgb %%ymm4,%%ymm0,%%ymm0 \n"
"vshufps $0x88,%%ymm3,%%ymm2,%%ymm4 \n"
"vshufps $0xdd,%%ymm3,%%ymm2,%%ymm2 \n"
"vpavgb %%ymm4,%%ymm2,%%ymm2 \n"
"vpmaddubsw %%ymm7,%%ymm0,%%ymm1 \n"
"vpmaddubsw %%ymm7,%%ymm2,%%ymm3 \n"
"vpmaddubsw %%ymm6,%%ymm0,%%ymm0 \n"
"vpmaddubsw %%ymm6,%%ymm2,%%ymm2 \n"
"vphaddw %%ymm3,%%ymm1,%%ymm1 \n"
"vphaddw %%ymm2,%%ymm0,%%ymm0 \n"
"vpsraw $0x8,%%ymm1,%%ymm1 \n"
"vpsraw $0x8,%%ymm0,%%ymm0 \n"
"vpacksswb %%ymm0,%%ymm1,%%ymm0 \n"
"vpermq $0xd8,%%ymm0,%%ymm0 \n"
"vpshufb %8,%%ymm0,%%ymm0 \n"
"vpaddb %%ymm5,%%ymm0,%%ymm0 \n"
"vextractf128 $0x0,%%ymm0,(%1) \n"
"vextractf128 $0x1,%%ymm0,0x0(%1,%2,1) \n"
"lea 0x10(%1),%1 \n"
"sub $0x20,%3 \n"
"jg 1b \n"
"vzeroupper \n"
: "+r"(src_abgr0), // %0
"+r"(dst_u), // %1
"+r"(dst_v), // %2
"+rm"(width) // %3
: "r"((intptr_t)(src_stride_abgr)), // %4
"m"(kAddUV128), // %5
"m"(kABGRToV), // %6
"m"(kABGRToU), // %7
"m"(kShufARGBToUV_AVX) // %8
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
"xmm7");
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
vbroadcastf128 0xa280f7(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vbroadcastf128 0xa2811e(%rip), %ymm6 # ymm6 = mem[0,1,0,1]
vbroadcastf128 0xa28125(%rip), %ymm7 # ymm7 = mem[0,1,0,1]
subq %rcx, %rax
vmovdqu (%rdx), %ymm0
vmovdqu 0x20(%rdx), %ymm1
vmovdqu 0x40(%rdx), %ymm2
vmovdqu 0x60(%rdx), %ymm3
vpavgb (%rdx,%rdi), %ymm0, %ymm0
vpavgb 0x20(%rdx,%rdi), %ymm1, %ymm1
vpavgb 0x40(%rdx,%rdi), %ymm2, %ymm2
vpavgb 0x60(%rdx,%rdi), %ymm3, %ymm3
leaq 0x80(%rdx), %rdx
vshufps $0x88, %ymm1, %ymm0, %ymm4 # ymm4 = ymm0[0,2],ymm1[0,2],ymm0[4,6],ymm1[4,6]
vshufps $0xdd, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[1,3],ymm1[1,3],ymm0[5,7],ymm1[5,7]
vpavgb %ymm4, %ymm0, %ymm0
vshufps $0x88, %ymm3, %ymm2, %ymm4 # ymm4 = ymm2[0,2],ymm3[0,2],ymm2[4,6],ymm3[4,6]
vshufps $0xdd, %ymm3, %ymm2, %ymm2 # ymm2 = ymm2[1,3],ymm3[1,3],ymm2[5,7],ymm3[5,7]
vpavgb %ymm4, %ymm2, %ymm2
vpmaddubsw %ymm7, %ymm0, %ymm1
vpmaddubsw %ymm7, %ymm2, %ymm3
vpmaddubsw %ymm6, %ymm0, %ymm0
vpmaddubsw %ymm6, %ymm2, %ymm2
vphaddw %ymm3, %ymm1, %ymm1
vphaddw %ymm2, %ymm0, %ymm0
vpsraw $0x8, %ymm1, %ymm1
vpsraw $0x8, %ymm0, %ymm0
vpacksswb %ymm0, %ymm1, %ymm0
vpermq $0xd8, %ymm0, %ymm0 # ymm0 = ymm0[0,2,1,3]
vpshufb 0xa2806a(%rip), %ymm0, %ymm0 # 0xa842c0
vpaddb %ymm5, %ymm0, %ymm0
vextractf128 $0x0, %ymm0, (%rcx)
vextractf128 $0x1, %ymm0, (%rcx,%rax)
leaq 0x10(%rcx), %rcx
subl $0x20, %esi
jg 0x5c1ce
vzeroupper
movl %esi, -0x24(%rsp)
movq %rdx, -0x8(%rsp)
movq %rcx, -0x18(%rsp)
movq %rax, -0x20(%rsp)
retq
nopl (%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ARGBToUVJRow_AVX2 | void ARGBToUVJRow_AVX2(const uint8_t* src_argb0,
int src_stride_argb,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"vbroadcastf128 %5,%%ymm5 \n"
"vbroadcastf128 %6,%%ymm6 \n"
"vbroadcastf128 %7,%%ymm7 \n"
"sub %1,%2 \n"
LABELALIGN
"1: \n"
"vmovdqu (%0),%%ymm0 \n"
"vmovdqu 0x20(%0),%%ymm1 \n"
"vmovdqu 0x40(%0),%%ymm2 \n"
"vmovdqu 0x60(%0),%%ymm3 \n"
"vpavgb 0x00(%0,%4,1),%%ymm0,%%ymm0 \n"
"vpavgb 0x20(%0,%4,1),%%ymm1,%%ymm1 \n"
"vpavgb 0x40(%0,%4,1),%%ymm2,%%ymm2 \n"
"vpavgb 0x60(%0,%4,1),%%ymm3,%%ymm3 \n"
"lea 0x80(%0),%0 \n"
"vshufps $0x88,%%ymm1,%%ymm0,%%ymm4 \n"
"vshufps $0xdd,%%ymm1,%%ymm0,%%ymm0 \n"
"vpavgb %%ymm4,%%ymm0,%%ymm0 \n"
"vshufps $0x88,%%ymm3,%%ymm2,%%ymm4 \n"
"vshufps $0xdd,%%ymm3,%%ymm2,%%ymm2 \n"
"vpavgb %%ymm4,%%ymm2,%%ymm2 \n"
"vpmaddubsw %%ymm7,%%ymm0,%%ymm1 \n"
"vpmaddubsw %%ymm7,%%ymm2,%%ymm3 \n"
"vpmaddubsw %%ymm6,%%ymm0,%%ymm0 \n"
"vpmaddubsw %%ymm6,%%ymm2,%%ymm2 \n"
"vphaddw %%ymm3,%%ymm1,%%ymm1 \n"
"vphaddw %%ymm2,%%ymm0,%%ymm0 \n"
"vpaddw %%ymm5,%%ymm0,%%ymm0 \n"
"vpaddw %%ymm5,%%ymm1,%%ymm1 \n"
"vpsraw $0x8,%%ymm1,%%ymm1 \n"
"vpsraw $0x8,%%ymm0,%%ymm0 \n"
"vpacksswb %%ymm0,%%ymm1,%%ymm0 \n"
"vpermq $0xd8,%%ymm0,%%ymm0 \n"
"vpshufb %8,%%ymm0,%%ymm0 \n"
"vextractf128 $0x0,%%ymm0,(%1) \n"
"vextractf128 $0x1,%%ymm0,0x0(%1,%2,1) \n"
"lea 0x10(%1),%1 \n"
"sub $0x20,%3 \n"
"jg 1b \n"
"vzeroupper \n"
: "+r"(src_argb0), // %0
"+r"(dst_u), // %1
"+r"(dst_v), // %2
"+rm"(width) // %3
: "r"((intptr_t)(src_stride_argb)), // %4
"m"(kSub128), // %5
"m"(kARGBToVJ), // %6
"m"(kARGBToUJ), // %7
"m"(kShufARGBToUV_AVX) // %8
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6",
"xmm7");
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
vbroadcastf128 0xa27f57(%rip), %ymm5 # ymm5 = mem[0,1,0,1]
vbroadcastf128 0xa2802e(%rip), %ymm6 # ymm6 = mem[0,1,0,1]
vbroadcastf128 0xa28035(%rip), %ymm7 # ymm7 = mem[0,1,0,1]
subq %rcx, %rax
vmovdqu (%rdx), %ymm0
vmovdqu 0x20(%rdx), %ymm1
vmovdqu 0x40(%rdx), %ymm2
vmovdqu 0x60(%rdx), %ymm3
vpavgb (%rdx,%rdi), %ymm0, %ymm0
vpavgb 0x20(%rdx,%rdi), %ymm1, %ymm1
vpavgb 0x40(%rdx,%rdi), %ymm2, %ymm2
vpavgb 0x60(%rdx,%rdi), %ymm3, %ymm3
leaq 0x80(%rdx), %rdx
vshufps $0x88, %ymm1, %ymm0, %ymm4 # ymm4 = ymm0[0,2],ymm1[0,2],ymm0[4,6],ymm1[4,6]
vshufps $0xdd, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[1,3],ymm1[1,3],ymm0[5,7],ymm1[5,7]
vpavgb %ymm4, %ymm0, %ymm0
vshufps $0x88, %ymm3, %ymm2, %ymm4 # ymm4 = ymm2[0,2],ymm3[0,2],ymm2[4,6],ymm3[4,6]
vshufps $0xdd, %ymm3, %ymm2, %ymm2 # ymm2 = ymm2[1,3],ymm3[1,3],ymm2[5,7],ymm3[5,7]
vpavgb %ymm4, %ymm2, %ymm2
vpmaddubsw %ymm7, %ymm0, %ymm1
vpmaddubsw %ymm7, %ymm2, %ymm3
vpmaddubsw %ymm6, %ymm0, %ymm0
vpmaddubsw %ymm6, %ymm2, %ymm2
vphaddw %ymm3, %ymm1, %ymm1
vphaddw %ymm2, %ymm0, %ymm0
vpaddw %ymm5, %ymm0, %ymm0
vpaddw %ymm5, %ymm1, %ymm1
vpsraw $0x8, %ymm1, %ymm1
vpsraw $0x8, %ymm0, %ymm0
vpacksswb %ymm0, %ymm1, %ymm0
vpermq $0xd8, %ymm0, %ymm0 # ymm0 = ymm0[0,2,1,3]
vpshufb 0xa27f52(%rip), %ymm0, %ymm0 # 0xa842c0
vextractf128 $0x0, %ymm0, (%rcx)
vextractf128 $0x1, %ymm0, (%rcx,%rax)
leaq 0x10(%rcx), %rcx
subl $0x20, %esi
jg 0x5c2de
vzeroupper
movl %esi, -0x24(%rsp)
movq %rdx, -0x8(%rsp)
movq %rcx, -0x18(%rsp)
movq %rax, -0x20(%rsp)
retq
nop
| /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ARGBToUVJRow_SSSE3 | void ARGBToUVJRow_SSSE3(const uint8_t* src_argb0,
int src_stride_argb,
uint8_t* dst_u,
uint8_t* dst_v,
int width) {
asm volatile(
"movdqa %5,%%xmm3 \n"
"movdqa %6,%%xmm4 \n"
"movdqa %7,%%xmm5 \n"
"sub %1,%2 \n"
LABELALIGN
"1: \n"
"movdqu (%0),%%xmm0 \n"
"movdqu 0x00(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm0 \n"
"movdqu 0x10(%0),%%xmm1 \n"
"movdqu 0x10(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm1 \n"
"movdqu 0x20(%0),%%xmm2 \n"
"movdqu 0x20(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm2 \n"
"movdqu 0x30(%0),%%xmm6 \n"
"movdqu 0x30(%0,%4,1),%%xmm7 \n"
"pavgb %%xmm7,%%xmm6 \n"
"lea 0x40(%0),%0 \n"
"movdqa %%xmm0,%%xmm7 \n"
"shufps $0x88,%%xmm1,%%xmm0 \n"
"shufps $0xdd,%%xmm1,%%xmm7 \n"
"pavgb %%xmm7,%%xmm0 \n"
"movdqa %%xmm2,%%xmm7 \n"
"shufps $0x88,%%xmm6,%%xmm2 \n"
"shufps $0xdd,%%xmm6,%%xmm7 \n"
"pavgb %%xmm7,%%xmm2 \n"
"movdqa %%xmm0,%%xmm1 \n"
"movdqa %%xmm2,%%xmm6 \n"
"pmaddubsw %%xmm4,%%xmm0 \n"
"pmaddubsw %%xmm4,%%xmm2 \n"
"pmaddubsw %%xmm3,%%xmm1 \n"
"pmaddubsw %%xmm3,%%xmm6 \n"
"phaddw %%xmm2,%%xmm0 \n"
"phaddw %%xmm6,%%xmm1 \n"
"paddw %%xmm5,%%xmm0 \n"
"paddw %%xmm5,%%xmm1 \n"
"psraw $0x8,%%xmm0 \n"
"psraw $0x8,%%xmm1 \n"
"packsswb %%xmm1,%%xmm0 \n"
"movlps %%xmm0,(%1) \n"
"movhps %%xmm0,0x00(%1,%2,1) \n"
"lea 0x8(%1),%1 \n"
"sub $0x10,%3 \n"
"jg 1b \n"
: "+r"(src_argb0), // %0
"+r"(dst_u), // %1
"+r"(dst_v), // %2
"+rm"(width) // %3
: "r"((intptr_t)(src_stride_argb)), // %4
"m"(kARGBToVJ), // %5
"m"(kARGBToUJ), // %6
"m"(kSub128) // %7
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm6", "xmm7");
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movq -0x8(%rsp), %rdx
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %esi
movslq -0xc(%rsp), %rdi
movdqa 0xa27f28(%rip), %xmm3 # 0xa84300
movdqa 0xa27f30(%rip), %xmm4 # 0xa84310
movdqa 0xa27e38(%rip), %xmm5 # 0xa84220
subq %rcx, %rax
movdqu (%rdx), %xmm0
movdqu (%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm0
movdqu 0x10(%rdx), %xmm1
movdqu 0x10(%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm1
movdqu 0x20(%rdx), %xmm2
movdqu 0x20(%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm2
movdqu 0x30(%rdx), %xmm6
movdqu 0x30(%rdx,%rdi), %xmm7
pavgb %xmm7, %xmm6
leaq 0x40(%rdx), %rdx
movdqa %xmm0, %xmm7
shufps $0x88, %xmm1, %xmm0 # xmm0 = xmm0[0,2],xmm1[0,2]
shufps $0xdd, %xmm1, %xmm7 # xmm7 = xmm7[1,3],xmm1[1,3]
pavgb %xmm7, %xmm0
movdqa %xmm2, %xmm7
shufps $0x88, %xmm6, %xmm2 # xmm2 = xmm2[0,2],xmm6[0,2]
shufps $0xdd, %xmm6, %xmm7 # xmm7 = xmm7[1,3],xmm6[1,3]
pavgb %xmm7, %xmm2
movdqa %xmm0, %xmm1
movdqa %xmm2, %xmm6
pmaddubsw %xmm4, %xmm0
pmaddubsw %xmm4, %xmm2
pmaddubsw %xmm3, %xmm1
pmaddubsw %xmm3, %xmm6
phaddw %xmm2, %xmm0
phaddw %xmm6, %xmm1
paddw %xmm5, %xmm0
paddw %xmm5, %xmm1
psraw $0x8, %xmm0
psraw $0x8, %xmm1
packsswb %xmm1, %xmm0
movlps %xmm0, (%rcx)
movhps %xmm0, (%rcx,%rax)
leaq 0x8(%rcx), %rcx
subl $0x10, %esi
jg 0x5c3eb
movl %esi, -0x24(%rsp)
movq %rdx, -0x8(%rsp)
movq %rcx, -0x18(%rsp)
movq %rax, -0x20(%rsp)
retq
nopl (%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/row_gcc.cc |
ScaleRowDown2Box_16_C | void ScaleRowDown2Box_16_C(const uint16_t* src_ptr,
ptrdiff_t src_stride,
uint16_t* dst,
int dst_width) {
const uint16_t* s = src_ptr;
const uint16_t* t = src_ptr + src_stride;
int x;
for (x = 0; x < dst_width - 1; x += 2) {
dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
dst[1] = (s[2] + s[3] + t[2] + t[3] + 2) >> 2;
dst += 2;
s += 4;
t += 4;
}
if (dst_width & 1) {
dst[0] = (s[0] + s[1] + t[0] + t[1] + 2) >> 2;
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x67a1c
movq -0x28(%rsp), %rax
movzwl (%rax), %eax
movq -0x28(%rsp), %rcx
movzwl 0x2(%rcx), %ecx
addl %ecx, %eax
movq -0x30(%rsp), %rcx
movzwl (%rcx), %ecx
addl %ecx, %eax
movq -0x30(%rsp), %rcx
movzwl 0x2(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, (%rax)
movq -0x28(%rsp), %rax
movzwl 0x4(%rax), %eax
movq -0x28(%rsp), %rcx
movzwl 0x6(%rcx), %ecx
addl %ecx, %eax
movq -0x30(%rsp), %rcx
movzwl 0x4(%rcx), %ecx
addl %ecx, %eax
movq -0x30(%rsp), %rcx
movzwl 0x6(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, 0x2(%rax)
movq -0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rsp)
movq -0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rsp)
movl -0x34(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x34(%rsp)
jmp 0x6795a
movl -0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x67a61
movq -0x28(%rsp), %rax
movzwl (%rax), %eax
movq -0x28(%rsp), %rcx
movzwl 0x2(%rcx), %ecx
addl %ecx, %eax
movq -0x30(%rsp), %rcx
movzwl (%rcx), %ecx
addl %ecx, %eax
movq -0x30(%rsp), %rcx
movzwl 0x2(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, (%rax)
retq
nopw %cs:(%rax,%rax)
| /m-ab-s[P]aom/third_party/libyuv/source/scale_common.cc |
ScaleRowDown4_C | void ScaleRowDown4_C(const uint8_t* src_ptr,
ptrdiff_t src_stride,
uint8_t* dst,
int dst_width) {
int x;
(void)src_stride;
for (x = 0; x < dst_width - 1; x += 2) {
dst[0] = src_ptr[2];
dst[1] = src_ptr[6];
dst += 2;
src_ptr += 8;
}
if (dst_width & 1) {
dst[0] = src_ptr[2];
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x67ae2
movq -0x8(%rsp), %rax
movb 0x2(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movb 0x6(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rsp)
movl -0x20(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rsp)
jmp 0x67a8b
movl -0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x67afd
movq -0x8(%rsp), %rax
movb 0x2(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
retq
nop
| /m-ab-s[P]aom/third_party/libyuv/source/scale_common.cc |
aom_img_add_metadata | int aom_img_add_metadata(aom_image_t *img, uint32_t type, const uint8_t *data,
size_t sz, aom_metadata_insert_flags_t insert_flag) {
if (!img) return -1;
if (!img->metadata) {
img->metadata = aom_img_metadata_array_alloc(0);
if (!img->metadata) return -1;
}
// Some metadata types are not allowed to be layer specific, according to
// the Table in Section 6.7.1 of the AV1 specifiction.
// Do not check for OBU_METADATA_TYPE_HDR_CLL or OBU_METADATA_TYPE_HDR_MDCV
// because there are plans to alow them to be layer specific.
if ((insert_flag & AOM_MIF_LAYER_SPECIFIC) &&
(type == OBU_METADATA_TYPE_SCALABILITY ||
type == OBU_METADATA_TYPE_TIMECODE)) {
return -1;
}
aom_metadata_t *metadata =
aom_img_metadata_alloc(type, data, sz, insert_flag);
if (!metadata) return -1;
aom_metadata_t **metadata_array =
(aom_metadata_t **)realloc(img->metadata->metadata_array,
(img->metadata->sz + 1) * sizeof(metadata));
if (!metadata_array) {
aom_img_metadata_free(metadata);
return -1;
}
img->metadata->metadata_array = metadata_array;
img->metadata->metadata_array[img->metadata->sz] = metadata;
img->metadata->sz++;
return 0;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xa0311
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa0456
movq 0x38(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0xa0356
xorl %eax, %eax
movl %eax, %edi
callq 0xa01d0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0xa0354
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa0456
jmp 0xa0356
movl 0x1c(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xa037d
cmpl $0x3, 0x34(%rsp)
je 0xa0370
cmpl $0x5, 0x34(%rsp)
jne 0xa037d
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa0456
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0xa00c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa03ae
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa0456
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq (%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x18810
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa03fb
movq 0x10(%rsp), %rdi
callq 0xa01a0
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa0456
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rsp), %rcx
movq 0x98(%rcx), %rcx
movq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
| /m-ab-s[P]aom/aom/src/aom_image.c |
aom_rb_read_primitive_quniform | static uint16_t aom_rb_read_primitive_quniform(struct aom_read_bit_buffer *rb,
uint16_t n) {
if (n <= 1) return 0;
const int l = get_msb(n) + 1;
const int m = (1 << l) - n;
const int v = aom_rb_read_literal(rb, l - 1);
return v < m ? v : (v << 1) - m + aom_rb_read_bit(rb);
} | subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movzwl 0x16(%rsp), %eax
cmpl $0x1, %eax
jg 0xa0b14
movw $0x0, 0x26(%rsp)
jmp 0xa0b8f
movzwl 0x16(%rsp), %edi
callq 0xa0ba0
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movzwl 0x16(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
subl $0x1, %esi
callq 0xa0660
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xa0b64
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0xa0b86
movl 0x8(%rsp), %eax
shll %eax
subl 0xc(%rsp), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xa05a0
movl %eax, %ecx
movl (%rsp), %eax
addl %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movw %ax, 0x26(%rsp)
movw 0x26(%rsp), %ax
addq $0x28, %rsp
retq
nopl (%rax)
| /m-ab-s[P]aom/aom_dsp/bitreader_buffer.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.