name string | code string | asm string | file string |
|---|---|---|---|
oadict_find | ion_err_t
oadict_find(
ion_dictionary_t *dictionary,
ion_predicate_t *predicate,
ion_dict_cursor_t **cursor
) {
/* allocate memory for cursor */
if ((*cursor = malloc(sizeof(ion_oadict_cursor_t))) == NULL) {
return err_out_of_memory;
}
(*cursor)->dictionary = dictionary;
(*cursor)->status = cs_cursor_u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
movl $0x38, %edi
callq 0x1150
movq %rax, (%rbx)
movb $0x6, %bpl
testq %rax, %rax
je 0x6661
movq %rax, %r14
movq %r13, 0x8(%rax)
movb $0x3, (%rax)
leaq 0x187(%rip), %rax # 0x6672
movq ... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash_dictionary_handler.c |
oadict_next | ion_cursor_status_t
oadict_next(
ion_dict_cursor_t *cursor,
ion_record_t *record
) {
ion_oadict_cursor_t *oadict_cursor = (ion_oadict_cursor_t *) cursor;
/* check the status of the cursor and if it is not valid or at the end, just exit */
if (cursor->status == cs_cursor_uninitialized) {
return cursor->status;
... | movzbl (%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x673d
leaq 0x5d7d(%rip), %rdx # 0xc428
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %r15
movl 0x4(%r15), %r12d
movl 0x8(... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash_dictionary_handler.c |
oadict_init | void
oadict_init(
ion_dictionary_handler_t *handler
) {
handler->insert = oadict_insert;
handler->create_dictionary = oadict_create_dictionary;
handler->get = oadict_get;
handler->update = oadict_update;
handler->find = oadict_find;
handler->remove = oadict_delete;
handler->delete_dictionary = oa... | leaq 0x67(%rip), %rax # 0x67b4
movq %rax, (%rdi)
leaq 0x66(%rip), %rax # 0x67bd
movq %rax, 0x8(%rdi)
leaq -0x346(%rip), %rax # 0x641c
movq %rax, 0x10(%rdi)
leaq 0xcb(%rip), %rax # 0x6838
movq %rax, 0x18(%rdi)
leaq -0x2ce(%rip), %rax # 0x64aa
movq %rax, 0x20(%rdi)
leaq 0xbe(%rip), %rax ... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash_dictionary_handler.c |
oadict_create_dictionary | ion_err_t
oadict_create_dictionary(
ion_dictionary_id_t id,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
ion_dictionary_size_t dictionary_size,
ion_dictionary_compare_t compare,
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary
) {
UNUSED(id);
/* th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq 0x48(%rsp), %r13
movl $0x38, %edi
callq 0x1150
movq %rax, 0x8(%r13)
movq %rbx, 0x10(%rax)
movl $0x3, 0x1c(%rax)
leaq 0x4b1(%rip), %rsi # 0x6cad
movq %... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash_dictionary_handler.c |
oah_initialize | ion_err_t
oah_initialize(
ion_hashmap_t *hashmap,
ion_hash_t (*hashing_function)(ion_hashmap_t *, ion_key_t, int),
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
int size
) {
int i;
hashmap->write_concern = wc_insert_unique; /* By default allow unique inserts only */
hashm... | pushq %r15
pushq %r14
pushq %rbx
movl %r9d, %ebx
movq %rsi, %r15
movq %rdi, %r14
movb $0x1, 0x24(%rdi)
movl %ecx, 0x4(%rdi)
movl %r8d, 0x8(%rdi)
movl %edx, (%rdi)
movl %r9d, 0x20(%rdi)
leal (%rcx,%r8), %eax
incl %eax
imull %r9d, %eax
movslq %eax, %rdi
callq 0x1150
movq %rax, 0x30(%r14)
movq %r15, 0x28(%r14)
testq %rax,... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_destroy | ion_err_t
oah_destroy(
ion_hashmap_t *hash_map
) {
hash_map->compute_hash = NULL;
hash_map->map_size = 0;
hash_map->super.record.key_size = 0;
hash_map->super.record.value_size = 0;
if (hash_map->entry != NULL) {
/* check to ensure that you are not freeing something already free */
free(hash_map->ent... | pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movl $0x0, 0x20(%rdi)
movq %rax, 0x4(%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x693f
callq 0x1030
movq $0x0, 0x30(%rbx)
xorl %eax, %eax
jmp 0x6941
movb $0x4, %al
popq %rbx
retq
| /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_insert | ion_status_t
oah_insert(
ion_hashmap_t *hash_map,
ion_key_t key,
ion_value_t value
) {
ion_hash_t hash = hash_map->compute_hash(hash_map, key, hash_map->super.record.key_size); /* compute hash value for given key */
int loc = oah_get_location(hash, hash_map->map_size);
/* Scan until find an empty location -... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x4(%rdi), %edx
callq *0x28(%rdi)
movl $0x3, %ebx
cmpl $0x0, 0x20(%r15)
je 0x6a2d
movq %r14, (%rsp)
cltd
idivl 0x20(%r15)
movl %edx, %ebp
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x30(%r15), %... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_find_item_loc | ion_err_t
oah_find_item_loc(
ion_hashmap_t *hash_map,
ion_key_t key,
int *location
) {
/* compute hash value for given key */
ion_hash_t hash = hash_map->compute_hash(hash_map, key, hash_map->super.record.key_size);
int loc = oah_get_location(hash, hash_map->map_size);
/* determine bucket based on hash */... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rdi), %edx
callq *0x28(%rdi)
cltd
idivl 0x20(%r15)
movl %edx, %ebp
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpl 0x20(%r15), %ebx
je 0x6b08
movq 0x30(%r15), %rdi
movl 0x4(%r15), %edx
movl 0x... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_delete | ion_status_t
oah_delete(
ion_hashmap_t *hash_map,
ion_key_t key
) {
int loc = -1;
if (oah_find_item_loc(hash_map, key, &loc) == err_item_not_found) {
#if ION_DEBUG
printf("Item not found when trying to oah_delete.\n");
#endif
return ION_STATUS_ERROR(err_item_not_found);
}
else {
/* locate item */
ion_ha... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0xffffffff, (%rdx) # imm = 0xFFFFFFFF
callq 0x6a75
movl %eax, %ecx
movl $0x1, %eax
cmpb $0x1, %cl
je 0x6b69
movq 0x30(%rbx), %rax
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %edx
addl %edx, %ecx
incl %ecx
movslq 0xc(%rsp), %rdx
movslq %ecx, %rcx
imulq ... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_get | ion_status_t
oah_get(
ion_hashmap_t *hash_map,
ion_key_t key,
ion_value_t value
) {
int loc;
if (oah_find_item_loc(hash_map, key, &loc) == err_ok) {
#if ION_DEBUG
printf("Item found at location %d\n", loc);
#endif
int data_length = hash_map->super.record.key_size + hash_map->super.record.value_size;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %rdx
callq 0x6a75
movl %eax, %ecx
movl $0x1, %eax
testb %cl, %cl
jne 0x6bc4
movslq 0x4(%r14), %rax
movslq 0x8(%r14), %rdx
leal (%rax,%rdx), %ecx
incl %ecx
movslq 0x4(%rsp), %rsi
movslq %ecx, %rcx
imulq %rsi, %rcx
addq 0x30(%r14), %rcx
leaq... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
oah_print | void
oah_print(
ion_hashmap_t *hash_map,
int size,
ion_record_info_t *record
) {
int i;
printf("Printing map\n");
for (i = 0; i < size; i++) {
printf("%d -- %i ", i, ((ion_hash_bucket_t *) ((hash_map->entry + (record->key_size + record->value_size + SIZEOF(STATUS)) * i)))->status);
{
if (((ion_hash_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x5867(%rip), %rdi # 0xc44d
callq 0x1070
testl %ebp, %ebp
jle 0x6c9e
leaq 0x584f(%rip), %r13 # 0xc449
xorl %r12d, %r12d
movq 0x30(%r14), %rax
movl (%rbx), %ecx
movl 0x4(%rbx), %edx... | /iondbproject[P]iondb/src/dictionary/open_address_hash/open_address_hash.c |
linear_hash_dict_init | void
linear_hash_dict_init(
ion_dictionary_handler_t *handler
) {
handler->insert = linear_hash_dict_insert;
handler->get = linear_hash_dict_get;
handler->create_dictionary = linear_hash_create_dictionary;
handler->remove = linear_hash_dict_delete;
handler->delete_dictionary = linear_hash_delete_dictiona... | leaq 0x5c(%rip), %rax # 0x6d23
movq %rax, (%rdi)
leaq 0x82(%rip), %rax # 0x6d53
movq %rax, 0x10(%rdi)
leaq 0x89(%rip), %rax # 0x6d65
movq %rax, 0x8(%rdi)
leaq 0x11a(%rip), %rax # 0x6e01
movq %rax, 0x28(%rdi)
leaq 0x11e(%rip), %rax # 0x6e10
movq %rax, 0x30(%rdi)
leaq 0x13e(%rip), %rax ... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash_handler.c |
linear_hash_create_dictionary | ion_err_t
linear_hash_create_dictionary(
ion_dictionary_id_t id,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
ion_dictionary_size_t dictionary_size,
ion_dictionary_compare_t compare,
ion_dictionary_handler_t *handler,
ion_dictionary_t *dictionary
) {
int initial_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, %r14d
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movl %esi, %r15d
movl %edi, %r13d
movq 0x48(%rsp), %rbx
movl $0x78, %edi
callq 0x1150
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6df0
movq 0x40(%rsp), %rbx
movq %r12, 0x10(%r... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash_handler.c |
linear_hash_destroy_dictionary | ion_err_t
linear_hash_destroy_dictionary(
ion_dictionary_id_t id
) {
char filename[ION_MAX_FILENAME_LENGTH];
dictionary_get_filename(id, "lhs", filename);
if (0 != fremove(filename)) {
return err_file_delete_error;
}
dictionary_get_filename(id, "lhd", filename);
if (0 != fremove(filename)) {
return err_f... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x560f(%rip), %rsi # 0xc45a
leaq 0xc(%rsp), %r14
movq %r14, %rdx
callq 0x37c4
movq %r14, %rdi
callq 0x1050
movl %eax, %ecx
movb $0xb, %al
testl %ecx, %ecx
jne 0x6e92
leaq 0x55ef(%rip), %rsi # 0xc45e
leaq 0xc(%rsp), %r14
movl %ebx, %edi
movq %r14, %rd... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash_handler.c |
linear_hash_close_dictionary | ion_err_t
linear_hash_close_dictionary(
ion_dictionary_t *dictionary
) {
ion_err_t err = linear_hash_close((linear_hash_table_t *) dictionary->instance);
if (dictionary->instance != NULL) {
free(dictionary->instance);
dictionary->instance = NULL;
}
if (err_ok != err) {
return err;
}
return err_ok;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x70c9
movl %eax, %ebp
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6ed3
callq 0x1030
movq $0x0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash_handler.c |
linear_hash_init | ion_err_t
linear_hash_init(
ion_dictionary_id_t id,
ion_dictionary_size_t dictionary_size,
ion_key_type_t key_type,
ion_key_size_t key_size,
ion_value_size_t value_size,
int initial_size,
int split_threshold,
int records_per_bucket,
linear_hash_table_t *linear_hash
) {
/* err */
ion_err... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
movq 0x50(%rsp), %rbx
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %edi
movl %ebp, 0x18(%rbx)
movl %esi, 0x20(%rbx)
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
movl %r9d, 0x24(%rbx)
movl %r9d, 0x30(%rbx)
xorl %edx, %edx
movl %edx, 0x... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
linear_hash_close | ion_err_t
linear_hash_close(
linear_hash_table_t *linear_hash
) {
if (0 != fclose(linear_hash->state)) {
linear_hash_write_state(linear_hash);
return err_file_close_error;
}
if (linear_hash->bucket_map->data != NULL) {
free(linear_hash->bucket_map->data);
linear_hash->bucket_map->data = NULL;
}
if (line... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0x10a0
testl %eax, %eax
je 0x70e9
movq %rbx, %rdi
callq 0x72b0
movb $0xa, %al
jmp 0x7151
movq 0x58(%rbx), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x7107
callq 0x1030
movq 0x58(%rbx), %rax
movq $0x0, 0x8(%rax)
movq 0x58(%rbx), %rdi
testq ... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
write_new_bucket | ion_err_t
write_new_bucket(
int idx,
linear_hash_table_t *linear_hash
) {
if (linear_hash->database == NULL) {
return err_file_open_error;
}
linear_hash_bucket_t bucket;
/* initialize bucket fields */
bucket.idx = idx;
bucket.record_count = 0;
bucket.overflow_location = linear_hash_end_of_list;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x7297
movq %rsi, %r14
movl %ebx, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movq $-0x1, -0x38(%rbp)
xorl %esi, %esi
movl $0x2, %edx
callq 0x1180
movl %eax, %ecx
movb $0xd... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
linear_hash_write_state | ion_err_t
linear_hash_write_state(
linear_hash_table_t *linear_hash
) {
if (1 != fwrite(&linear_hash->initial_size, sizeof(linear_hash->initial_size), 1, linear_hash->state)) {
return err_file_write_error;
}
if (1 != fwrite(&linear_hash->next_split, sizeof(linear_hash->next_split), 1, linear_hash->state)) {
re... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
addq $0x24, %rdi
movq 0x50(%rbx), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x11f0
movb $0x7, %r14b
cmpq $0x1, %rax
jne 0x740b
leaq 0x28(%rbx), %rdi
movq 0x50(%rbx), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x11f0
cmpq $0x1, %rax
... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
linear_hash_read_state | ion_err_t
linear_hash_read_state(
linear_hash_table_t *linear_hash
) {
if (0 != fseek(linear_hash->state, 0, SEEK_SET)) {
return err_file_bad_seek;
}
if (1 != fread(&(linear_hash->initial_size), sizeof(linear_hash->initial_size), 1, linear_hash->state)) {
return err_file_read_error;
}
if (1 != fread(&linear... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1180
movb $0xd, %bpl
testl %eax, %eax
jne 0x7541
leaq 0x24(%rbx), %rdi
movq 0x50(%rbx), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1080
movb $0x8, %bpl
cmpq $0x1, %rax
jne 0x7541
leaq 0x28(%rbx), %rdi
movq 0... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
linear_hash_increment_num_records | ion_err_t
linear_hash_increment_num_records(
linear_hash_table_t *linear_hash
) {
linear_hash->num_records++;
ion_err_t err = err_ok;
if (linear_hash_above_threshold(linear_hash)) {
err = write_new_bucket(linear_hash->num_buckets, linear_hash);
if (err != err_ok) {
return err;
}
linear_hash_increment... | pushq %rbx
movq %rdi, %rbx
movl 0x30(%rdi), %edi
movl 0x34(%rbx), %eax
incl %eax
movl %eax, 0x34(%rbx)
imull $0x64, %eax, %eax
cvtsi2sd %eax, %xmm0
movl 0x38(%rbx), %eax
imull %edi, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x2c(%rbx), %xmm1
ucomisd %xmm1, %xmm0
ja 0x758d
xorl %eax, %eax... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
split | ion_err_t
split(
linear_hash_table_t *linear_hash
) {
/* status to hold amount of records deleted */
ion_status_t status = ION_STATUS_INITIALIZE;
/* get bucket to split */
ion_fpos_t bucket_loc = bucket_idx_to_ion_fpos_t(linear_hash->next_split, linear_hash);
linear_hash_bucket_t bucket;
status.error = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movslq 0x28(%rdi), %rax
movq 0x58(%rdi), %rcx
movq $-0x1, %r13
cmpl %eax, (%rcx)
jle 0x7635
movq 0x8(%rcx), %rcx
movq (%rcx,%rax,8), %r13
leaq -0x58(%rbp), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x7906... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
linear_hash_get_bucket | ion_err_t
linear_hash_get_bucket(
ion_fpos_t bucket_loc,
linear_hash_bucket_t *bucket,
linear_hash_table_t *linear_hash
) {
if (bucket_loc == -1) {}
/* check if file is open */
if (!linear_hash->database) {
return err_file_close_error;
}
/* seek to location of record in file */
if (0 != fseek(linear_ha... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x48(%rdx), %rdi
testq %rdi, %rdi
je 0x7974
movq %rdx, %r14
xorl %edx, %edx
callq 0x1180
movl %eax, %ecx
movb $0xd, %al
testl %ecx, %ecx
jne 0x7976
movq %rsp, %r15
addq $-0x10, %r15
movq %r15, %rsp
movq 0x48(%r14... | /iondbproject[P]iondb/src/dictionary/linear_hash/linear_hash.c |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<double, double>, Eigen::ArrayWrapper<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, -1,... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %r8
movq 0x28(%rsi), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x7354
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx... | /haukri[P]MasterProject/Eigen/src/Core/PlainObjectBase.h |
ANN::fit(Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>) | void ANN::fit(Eigen::MatrixXd X, Eigen::MatrixXd y) {
// Calculate feed forward for X
Eigen::MatrixXd predicted = predict(X);
// Calculate error for output
Eigen::MatrixXd error = y - predicted;
error.transposeInPlace();
// Backpropagate error
for(int i = layers.size()-1; i > 0; i--) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rdi, %r14
leaq 0x70(%rsp), %r12
movq %r12, %rdi
callq 0x7238
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x7952
movq 0x70(%rsp), %rdi
callq 0x6220
movq %r15, 0x28(%rsp)
movq %rbx, 0x3... | /haukri[P]MasterProject/Network/ANN/ANN.cpp |
ANN::~ANN() | ANN::~ANN()
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x7a3f
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x61f0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7a54
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x61f0
popq %rbx
retq
| /haukri[P]MasterProject/Network/ANN/ANN.cpp |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>>(Eigen::DenseBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_dif... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq 0x8(%rax), %r8
movq 0x10(%rax), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x7ca8
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFF... | /haukri[P]MasterProject/Eigen/src/Core/PlainObjectBase.h |
Eigen::internal::product_evaluator<Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, 8, Eigen::DenseShape, Eigen::DenseShape, double, double>::product_evaluator(Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0> cons... | explicit product_evaluator(const XprType& xpr)
: m_result(xpr.rows(), xpr.cols())
{
::new (static_cast<Base*>(this)) Base(m_result);
// FIXME shall we handle nested_eval here?,
// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product... | pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
movq %rax, (%rdi)
movq $-0x1, 0x8(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq 0x8(%rcx), %r8
movq 0x10(%rdx), %rcx
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rcx, %rax
orq %r8, %rax
js 0x912e
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%r... | /haukri[P]MasterProject/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::CwiseNullaryOp<Eigen::int... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq 0x10(%rsi), %xmm7
movq (%rsi), %r14
movq 0x8(%rsi), %rbx
cmpq %r14, 0x8(%rdi)
jne 0x9835
movq %rbx, %rax
movq %r14, %rcx
cmpq %rbx, 0x10(%r15)
je 0x9890
movq %rbx, %rax
orq %r14, %rax
js 0x99a6
movdqa %xmm7, (%rsp)
testq %r14, %r14
sete %al
testq %r... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::gemm_pack_lhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 1>, 4, 2, 1, false, false>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 1> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode>
::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
{
typedef typename packet_traits<Scalar>::type Packet;
enum { PacketSize = packet_traits<Scalar>::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x10(%rsp)
orq 0xd0(%rsp), %r9
jne 0xd38a
movq %rdx, %rdi
movq %rcx, %r15
shrq $0x3f, %r15
addq %rcx, %r15
andq $-0x2, %r15
leaq 0x18(%rsi), %rax
movq %rax, 0x70(%rsp)
movl $0x4, %edx
xorl %r9d, %r9d
xorl %r10d, %r10d
movq %rcx... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
FIR::stopband(int, double, double) | void FIR::stopband(int M, double f1, double f2){
this->setTaps(M);
freq.resize(2);
if (f1<0.0 or f1>0.5 or f2<0.0 or f2>0.5){printf("\nThe frequencies are not normalized\n");}
else{
this->setFreq(f1,0);
this->setFreq(f2,1);
this->setType('s');
int M=this->getTaps();
for (int i=-int(M/2); i<int(M/2);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xde8e
leaq 0x28(%rbx), %rdi
movl $0x2, %esi
callq 0xe6dc
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm0
ucomisd 0x66c4(%rip), %xmm2 # 0x14920
ja 0xe3c9
xorpd %xmm1, %xmm1
... | /haukri[P]MasterProject/Network/utils/FIR.cpp |
Scene::trace(Grayzer::Medium&, double, Ray&) | Color Scene::trace(Grayzer::Medium& curMed, double weight, Ray& ray)
{
GeometricObject *obj;
double t = GEOM_INFINITY;
Color color;
level++;
Stats::raysCast();
if((obj = intersect(ray,t)) != 0)
{
color = shade(curMed, weight, ray.point(t), ray.dir, obj);
if(curMed.beta > threshold) co... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r12
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x40dd4c0000000000, %rax # imm = 0x40DD4C0000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x6992(%rip), %r13 # 0xa1e8
incl (%r13)
leaq 0x699... | /berkus[P]grayzer/src/environment/Scene.cpp |
PointLight::shadow(Scene*, Vector&, Vector&) | double PointLight::shadow(Scene* scene, Vector& p, Vector& l)
{
l = loc - p;
double t;
double dist = !l;
double attenuation = dist_scale / dist;
attenuation = attenuation * attenuation;
l /= dist;
Ray r(p,l);
SurfaceData texture;
GeometricObject *occlude;
while ((occlude = scene-... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movq %rdi, %r12
movsd 0x20(%rdi), %xmm1
movsd 0x28(%rdi), %xmm2
subsd (%rdx), %xmm1
subsd 0x8(%rdx), %xmm2
movq %rcx, %r15
movsd 0x30(%rdi), %xmm0
subsd 0x10(%rdx), %xmm0
movq %rsi, %rbx
movsd %xmm1, (%rcx)
movsd %xmm2, 0x8(%rcx)
mo... | /berkus[P]grayzer/src/light/PointLight.cpp |
main | int main(int argc, char** argv) {
char word_a[1024];
char word_b[1024];
printf("Please input two words to be displayed vertically:\n");
do {
printf("> ");
if (fgets(word_a, sizeof word_a, stdin) == NULL) return 1;
} while (word_a[0] == '\n');
do {
printf("> ");
if (fgets(word_b, sizeof word... | pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp # imm = 0x830
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe94(%rip), %rdi # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0xeba(%rip), %rdi # 0x2038
movb $0x0, %al
callq 0x1030
leaq -0x410(%rbp), %rdi
movq 0x2e4d(%rip), %rax ... | /adri326[P]ife-exs/src/13/13.6/main.c |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x269fe
movq 0xa1a7a3(%rip), %rax # 0xa57f00
addq %r15, %r14
cmpb $0x1, 0x200(%rax)
jne 0x3d789
testb $0x1, %r12b
je 0x3d777
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
... | /iamrinni[P]xlearn/gtest/src/gtest.cc |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x1d7c0
testq %rax, %rax
je 0x3d8f3
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x1d5d0
testl %eax, %eax
je 0x3d963
leaq 0x9e98(%rip), %rdx # 0x4779d
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x5ce, %ecx ... | /iamrinni[P]xlearn/gtest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's downcast.
#endif
} | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3f9d3
movq (%rdi), %rax
movq %rdi, %rbx
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x89a7(%rip), %rax # 0x48306
cmpq %rax, %rdi
je 0x3f9b6
cmpb $0x2a, (%rdi)
je 0x3f979
leaq 0x8996(%rip), %rsi # 0x48306
callq 0x1d720
testl %eax, %eax
je 0x3f9b6
leaq 0x7e1... | /iamrinni[P]xlearn/gtest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::SocketWriter::SocketWriter(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&) | SocketWriter(const string& host, const string& port)
: sockfd_(-1), host_name_(host), port_num_(port) {
MakeConnection();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x170e6(%rip), %rax # 0x56ce8
leaq 0x20(%rdi), %r13
movq %rdx, %r12
leaq 0x10(%rdi), %rbx
movq %rdi, %r14
movq %rax, (%rdi)
movl $0xffffffff, 0x8(%rdi) # imm = 0xFFFFFFFF
movq %r13, 0x10(%rdi)
movq %rbx, %rdi
movq (%rsi), %rax
movq 0... | /iamrinni[P]xlearn/gtest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | void OnTestPartResult(const TestPartResult& test_part_result) {
const char* file_name = test_part_result.file_name();
if (file_name == NULL)
file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq 0x10(%rsi), %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rax, %rax
je 0x400a5
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x6b3a(%rip), %rsi # 0x46be9
leaq 0xf0(%rsp), %r15
cmovneq %rax, %rsi
movq %r15, %rdi
callq ... | /iamrinni[P]xlearn/gtest/src/gtest-internal-inl.h |
Args::Arg::~Arg() | inline
Arg::~Arg()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x14a35(%rip), %rax # 0x18800
movq %rax, (%rdi)
movq 0xd8(%rdi), %rdi
leaq 0xe8(%rbx), %rax
cmpq %rax, %rdi
je 0x3dec
movq (%rax), %rsi
incq %rsi
callq 0x3180
movq 0xb8(%rbx), %rdi
leaq 0xc8(%rbx), %rax
cmpq %rax, %rdi
je 0x3e0a
movq (%rax), %rsi
incq %rsi
callq 0x3180
movq 0x98(%rbx... | /igormironchik[P]args-parser/samples/api/../../args-parser/arg.hpp |
Args::Help::process(Args::Context&) | inline void
Help::process( Context & context )
{
if( !context.atEnd() )
{
String arg = *context.next();
// Argument or flag.
if( details::isArgument( arg ) || details::isFlag( arg ) )
m_printer->print( arg, g_argsOutStream );
// Command?
else
{
auto * tmp = m_printer->findArgument( arg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x3fc4
movq %rsi, %r14
leaq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsi)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8... | /igormironchik[P]args-parser/samples/api/../../args-parser/help.hpp |
Args::Command::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ArgIface * findChild(
/*!
Name of the argument. Can be for example "-t" or
"--timeout".
*/
const String & name )
{
auto * arg = GroupIface::findArgument( name );
if( !arg && m_subCommand )
return m_subCommand->findChild( name );
return arg;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%r14), %r12
movq 0x18(%r14), %r13
cmpq %r13, %r12
je 0x4258
movq 0x8(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x70(%rax)
testq %rax, %rax
cmovneq %rax, %r15
jne 0x425b
addq $0x10, %r12
cmpq %r13, %r12
jne 0x4238... | /igormironchik[P]args-parser/samples/api/../../args-parser/command.hpp |
Args::HelpHasBeenPrintedException::HelpHasBeenPrintedException() | HelpHasBeenPrintedException()
: BaseException( SL( "Help has been printed." ) )
{
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xde7c(%rip), %rsi # 0x12110
leaq 0xde8b(%rip), %rdx # 0x12126
leaq 0x8(%rsp), %rdi
callq 0x9dae
leaq 0xde7b(%rip), %rsi # 0x12127
movq %rbx, %rdi
callq 0x31f0
leaq 0x147ed(%rip), %rax # 0x18aa8
m... | /igormironchik[P]args-parser/samples/api/../../args-parser/exceptions.hpp |
Args::BaseException::~BaseException() | virtual ~BaseException() noexcept
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x14767(%rip), %rax # 0x18aa8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x435c
movq (%rax), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
popq %rbx
jmp 0x32b0
nop
| /igormironchik[P]args-parser/samples/api/../../args-parser/exceptions.hpp |
Args::HelpPrinter::~HelpPrinter() | inline
HelpPrinter::~HelpPrinter()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x14587(%rip), %rax # 0x188f8
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x438c
movq (%rax), %rsi
incq %rsi
callq 0x3180
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x43a4
movq (%rax), %rsi
incq %rsi
callq 0x3180
movl $0x58, %es... | /igormironchik[P]args-parser/samples/api/../../args-parser/help_printer.hpp |
Args::HelpPrinter::~HelpPrinter() | inline
HelpPrinter::~HelpPrinter()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1453b(%rip), %rax # 0x188f8
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x43d8
movq (%rax), %rsi
incq %rsi
callq 0x3180
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x43f1
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x3180
popq %rbx
re... | /igormironchik[P]args-parser/samples/api/../../args-parser/help_printer.hpp |
Args::CmdLine::CmdLine(int, char const* const*, int) | CmdLine::CmdLine( int argc, const char * const * argv, CmdLineOpts opt )
#endif
: details::API< CmdLine, CmdLine, ArgPtr, true > ( *this, *this )
, m_context( details::makeContext( argc, argv ) )
, m_command( nullptr )
, m_currCommand( nullptr )
, m_opt( opt )
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0xc(%rsp)
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, 0x10(%rdi)
leaq 0x146b8(%rip), %rax # 0x18ad0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
cmpl $0x2, %esi
jl 0x4486
movq %rd... | /igormironchik[P]args-parser/samples/api/../../args-parser/cmd_line.hpp |
Args::Help::Help(bool) | inline
Help::Help( bool throwExceptionOnPrint )
: Arg( SL( 'h' ), SL( "help" ), true, false )
, m_printer( new HelpPrinter )
, m_throwExceptionOnPrint( throwExceptionOnPrint )
{
setDescription( SL( "Print this help." ) );
setLongDescription( SL( "Print this help." ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x9ad4(%rip), %rdx # 0x1216c
movl $0x68, %esi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8a0a
leaq 0x102c7(%rip), %rax # 0x18978
movq %rax, (%rbx)
movl $0x58, %edi
callq 0x3170
leaq 0x10233(%rip), %rcx # 0x188f8
... | /igormironchik[P]args-parser/samples/api/../../args-parser/cmd_line.hpp |
Args::Command::Command<char const (&) [4]>(char const (&) [4], Args::ValueOptions, bool) | explicit Command( T && nm,
ValueOptions opt = ValueOptions::NoValue,
bool isSubCommandRequired = false )
: GroupIface( std::forward< T > ( nm ) )
, m_opt( opt )
, m_isDefined( false )
, m_isSubCommandRequired( isSubCommandRequired )
, m_subCommand( nullptr )
{
if( details::isArgument( name() ) || detai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edx, %edx
callq 0xfcd4
leaq 0x9492(%rip), %rax # 0x18c08
movq %rax, (%rbx)
movl %r14d, 0x4c(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x70(%rsp)
leaq 0x60(%rbx), ... | /igormironchik[P]args-parser/samples/api/../../args-parser/command.hpp |
Args::GroupIface::GroupIface<char const (&) [4]>(char const (&) [4], bool) | explicit GroupIface( T && name,
bool required = false )
: m_name( std::forward< T > ( name ) )
, m_required( required )
{
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x8fe6(%rip), %rcx # 0x18cd8
movq %rcx, (%rdi)
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %r13
leaq 0x38(%rd... | /igormironchik[P]args-parser/samples/api/../../args-parser/group_iface.hpp |
Args::GroupIface::name[abi:cxx11]() const | String name() const override
{
return m_name;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xf6bc
movq %rbx, %rax
popq %rbx
retq
nop
| /igormironchik[P]args-parser/samples/api/../../args-parser/group_iface.hpp |
Args::GroupIface::checkCorrectnessAfterParsing() const | void checkCorrectnessAfterParsing() const override
{
for( const auto & arg : details::asConst( m_children ) )
arg->checkCorrectnessAfterParsing();
if( isRequired() && !isDefined() )
throw BaseException(
String( SL( "Not defined required argument \"" ) ) +
name() + SL( "\"" ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rbx
movq 0x18(%rdi), %r15
cmpq %r15, %rbx
je 0x10fd8
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
addq $0x10, %rbx
jmp 0x10fc0
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x10f... | /igormironchik[P]args-parser/samples/api/../../args-parser/group_iface.hpp |
assertion_equal_mem | int
assertion_equal_mem(const char *file, int line,
const void *_v1, const char *e1,
const void *_v2, const char *e2,
size_t l, const char *ld, void *extra)
{
const char *v1 = (const char *)_v1;
const char *v2 = (const char *)_v2;
size_t offset;
assertion_count(file, line);
if (v1 == v2 || (v1 != NULL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x2ddb4(%rip) # 0x31118
movq 0x19475(%rip), %rax # 0x1c7e0
movq %rax, 0x1a48e(%rip) # 0x1d800
movq $0x0, 0x19463(%rip) # 0x1c7e0
movl $0x1, %ebx
cmpq %r8, %rdx
je 0x34d6
movq %r8, %r14
movq %rdx, %r15
movq 0x40(%rsp), %r... | /Tarsnap[P]libarchive/test_utils/test_main.c |
canLzma | int
canLzma(void)
{
static int tested = 0, value = 0;
if (!tested) {
tested = 1;
if (systemf("lzma --help %s", redirectArgs) == 0)
value = 1;
}
return (value);
} | cmpb $0x0, 0x2c15a(%rip) # 0x310d4
jne 0x4fa9
pushq %rax
movb $0x1, 0x2c150(%rip) # 0x310d4
leaq 0xcb50(%rip), %rdi # 0x11adb
leaq 0xd0f8(%rip), %rsi # 0x1208a
xorl %eax, %eax
callq 0x4b8f
testl %eax, %eax
leaq 0x8(%rsp), %rsp
jne 0x4fa9
movb $0x1, 0x2c12f(%rip) # 0x310d8
movzbl 0x2c128(%rip), %ea... | /Tarsnap[P]libarchive/test_utils/test_main.c |
despot::BaseTag::ReadConfig(std::istream&) | void BaseTag::ReadConfig(istream& is) {
string line, key, val;
while (is >> key >> val) {
if (key == "mapSize") {
int nrows, ncols;
is >> nrows >> ncols;
floor_ = Floor(nrows, ncols);
for (int y = 0; y < nrows; y++) {
is >> line;
for (int x = 0; x < ncols; x++) {
if (line[x] != '#') {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rsi, 0x10(%rsp)
leaq 0x58(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xa8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq ... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::Init(std::istream&) | void BaseTag::Init(istream& is) {
ReadConfig(is);
TagState* state;
states_.resize(NumStates());
rob_.resize(NumStates());
opp_.resize(NumStates());
for (int rob = 0; rob < floor_.NumCells(); rob++) {
for (int opp = 0; opp < floor_.NumCells(); opp++) {
int s = RobOppIndicesToStateIndex(rob, opp);
state = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
callq 0xe4b4
leaq 0x98(%rbx), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movslq %eax, %rsi
movq %r14, %rdi
callq 0x125e4
leaq 0xb0(%rbx), %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movslq %eax,... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
non-virtual thunk to despot::BaseTag::~BaseTag() | bool BaseTag::Step(State& s, double random_num, ACT_TYPE action,
double& reward) const {
TagState& state = static_cast<TagState&>(s);
bool terminal = false;
if (action == TagAction()) {
if (rob_[state.state_id] == opp_[state.state_id]) {
reward = TAG_REWARD;
terminal = true;
} else {
reward = -TAG_REW... | addq $-0x40, %rdi
jmp 0xff50
nop
| /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
non-virtual thunk to despot::BaseTag::~BaseTag() | bool BaseTag::Step(State& s, double random_num, ACT_TYPE action,
double& reward) const {
TagState& state = static_cast<TagState&>(s);
bool terminal = false;
if (action == TagAction()) {
if (rob_[state.state_id] == opp_[state.state_id]) {
reward = TAG_REWARD;
terminal = true;
} else {
reward = -TAG_REW... | addq $-0x50, %rdi
jmp 0xff50
nop
| /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::Step(despot::State&, double, int, double&) const | bool BaseTag::Step(State& s, double random_num, ACT_TYPE action,
double& reward) const {
TagState& state = static_cast<TagState&>(s);
bool terminal = false;
if (action == TagAction()) {
if (rob_[state.state_id] == opp_[state.state_id]) {
reward = TAG_REWARD;
terminal = true;
} else {
reward = -TAG_REW... | cmpl $0x4, %edx
jne 0x100df
movslq 0xc(%rsi), %r8
movq 0xb0(%rdi), %rax
movq 0xc8(%rdi), %r9
movl (%rax,%r8,4), %r10d
movb $0x1, %al
movsd 0x10309(%rip), %xmm1 # 0x203d8
cmpl (%r9,%r8,4), %r10d
je 0x100e9
xorpd 0x8f43(%rip), %xmm1 # 0x19020
jmp 0x100e7
movsd 0x8f59(%rip), %xmm1 # 0x19040
xorl %eax, %eax
movs... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::PrintTransitions() const | void BaseTag::PrintTransitions() const {
for (int s = 0; s < NumStates(); s++) {
cout << "State " << s << endl;
PrintState(*GetState(s));
for (int a = 0; a < NumActions(); a++) {
cout << "Applying action " << a << " on " << endl;
for (int i = 0; i < transition_probabilities_[s][a].size();
i++) {
co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jle 0x10449
xorl %r14d, %r14d
movq 0xfdc9(%rip), %r13 # 0x1ffb0
movl $0x6, %edx
movq %r13, %rdi
leaq 0x8f20(%rip), %rsi # 0x19116
callq 0xd430
movq %r13, %rdi... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
non-virtual thunk to despot::BaseTag::CreateBeliefUpperBound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | BeliefUpperBound* BaseTag::CreateBeliefUpperBound(string name) const {
if (name == "TRIVIAL") {
return new TrivialBeliefUpperBound(this);
} else if (name == "DEFAULT" || name == "MDP") {
return new MDPUpperBound(this, *this);
} else if (name == "MANHATTAN") {
return new TagManhattanUpperBound(this);
} else {
... | addq $-0x38, %rdi
jmp 0x10888
nop
| /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::CreateBeliefLowerBound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | BeliefLowerBound* BaseTag::CreateBeliefLowerBound(string name) const {
if (name == "TRIVIAL") {
return new TrivialBeliefLowerBound(this);
} else if (name == "DEFAULT" || name == "BLIND") {
return new TagBlindBeliefPolicy(this);
} else {
cerr << "Unsupported belief lower bound: " << name << endl;
exit(1);
r... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7e3f(%rip), %rsi # 0x19376
movq %r14, %rdi
callq 0xd130
testl %eax, %eax
je 0x11583
leaq 0x7beb(%rip), %rsi # 0x19135
movq %r14, %rdi
callq 0xd130
testl %eax, %eax
je 0x11569
leaq 0x7e21(%rip), %rsi # 0x1937e
movq %r14, %rdi
callq 0x... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::CreatePOMCPPrior(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | POMCPPrior* BaseTag::CreatePOMCPPrior(string name) const {
if (name == "UNIFORM") {
return new UniformPOMCPPrior(this);
} else if (name == "DEFAULT" || name == "SHR") {
return new TagPOMCPPrior(this);
} else {
cerr << "Unsupported POMCP prior: " << name << endl;
exit(1);
return NULL;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7d8e(%rip), %rsi # 0x193a5
movq %r14, %rdi
callq 0xd130
testl %eax, %eax
je 0x11672
leaq 0x7b0b(%rip), %rsi # 0x19135
movq %r14, %rdi
callq 0xd130
testl %eax, %eax
je 0x11649
leaq 0x7c55(%rip), %rsi # 0x19292
movq %r14, %rdi
callq 0x... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::PrintState(despot::State const&, std::ostream&) const | void BaseTag::PrintState(const State& s, ostream& out) const {
const TagState& state = static_cast<const TagState&>(s);
int aindex = rob_[state.state_id];
int oindex = opp_[state.state_id];
for (int y = floor_.num_rows()-1; y >= 0; y--) {
for (int x = 0; x < floor_.num_cols(); x++) {
int index = floor_.GetIn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movslq 0xc(%rsi), %rax
movq 0xb0(%rdi), %rcx
movq 0xc8(%rdi), %rdx
movl (%rcx,%rax,4), %ecx
movl %ecx, 0x4(%rsp)
movl (%rdx,%rax,4), %eax
movl %eax, (%rsp)
addq $0x58, %rdi
movq %rdi, 0x10(%rsp)
callq 0xd2... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::BaseTag::GetMMAP(std::vector<despot::State*, std::allocator<despot::State*>> const&) const | const State* BaseTag::GetMMAP(const vector<State*>& particles) const {
Coord rob = MostLikelyRobPosition(particles);
Coord opp = MostLikelyOpponentPosition(particles);
int state_id = RobOppIndicesToStateIndex(floor_.GetIndex(rob),
floor_.GetIndex(opp));
return states_[state_id];
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x11b4e
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11a0a
movq 0xe1b1(%rip), %rcx # 0x1ffc8
movq %rcx, %rdx
testl %r14d, %r14d
js 0x11e55
movq %rcx, %rdx
testq %r14, %r14
js 0x11e55
movq %rcx, %rdx
cmpl %r14d, 0x5c(%rbx)
jle 0x11e55... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> despot::to_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string to_string(T t) {
std::ostringstream oss;
oss << t;
return oss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xd4d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xd430
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xd5d0
movq 0xdaac(%rip), %rsi # 0x1ffa8
leaq... | /AdaCompNUS[P]despot/include/despot/util/util.h |
despot::MemoryPool<despot::TagState>::Allocate() | T* Allocate() {
if (freelist_.empty())
NewChunk();
T* obj = freelist_.back();
freelist_.pop_back();
assert(!obj->IsAllocated());
obj->SetAllocated();
num_allocated_++;
return obj;
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jne 0x12e16
movq %rbx, %rdi
callq 0x16214
movq 0x20(%rbx), %rcx
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
cmpb $0x1, 0x8(%rax)
je 0x12e35
movb $0x1, 0x8(%rax)
incl 0x30(%rbx)
popq %rbx
retq
leaq 0x6637(%rip), %rdi # 0x19473
l... | /AdaCompNUS[P]despot/include/despot/util/memorypool.h |
despot::TagManhattanUpperBound::Value(despot::Belief const*) const | double Value(const Belief* belief) const {
const vector<State*>& particles =
static_cast<const ParticleBelief*>(belief)->particles();
double value = 0;
for (int i = 0; i < particles.size(); i++) {
State* particle = particles[i];
const TagState* state = static_cast<const TagState*>(particle);
value +=... | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x30(%rax)
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
je 0x13697
sarq $0x3, %rax
movq 0x18(%rbx), %rdx
cmpq $0x1, %rax
adcq $0x0, %rax
xorpd %xmm0, %xmm0
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movsd 0x18(%rdi), %xmm1
movslq 0xc(%rdi), %rd... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::TagSHRPolicy::Action(std::vector<despot::State*, std::allocator<despot::State*>> const&, despot::RandomStreams&, despot::History&) const | ACT_TYPE Action(const vector<State*>& particles, RandomStreams& streams,
History& history) const {
// If history is empty then take a random move
if (history.Size() == 0) {
return Random::RANDOM.NextInt(tag_model_->NumActions() - 1);
}
// If we just saw an opponent then TAG
if (history.LastObservation()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
movq 0x8(%rcx), %rax
cmpq (%rcx), %rax
je 0x13851
movq %rcx, %r14
movq 0x20(%rcx), %rax
movq -0x8(%rax), %rax
movq 0x20(%r12), %rcx
movl $0x4, %ebx
cmpq 0xf8(%rcx), %rax
je 0x139d2
movq %rsi, %r15
xorps %xmm0, %xmm0
movap... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::TagHistoryModePolicy::ComputeMode(despot::Belief*) const | State ComputeMode(Belief* belief) const {
const vector<State*>& particles = static_cast<ParticleBelief*>(belief)->particles();
double maxWeight = 0;
State mode;
for (int i = 0; particles.size(); i++) {
State* particle = particles[i];
int id = particle->state_id;
state_probs_[id] += particle->weight;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x30(%rax)
movq %rax, %r15
movq %rbx, %rdi
callq 0xd480
movq (%r15), %rax
movq 0x8(%r15), %rdx
cmpq %rax, %rdx
je 0x1488c
movq 0x90(%r14), %rcx
leaq 0xc(%rbx), %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
movq (%rax,%rd... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/base/base_tag.cpp |
despot::LaserTag::Step(despot::State&, double, int, double&, unsigned long&) const | bool LaserTag::Step(State& state, double random_num, ACT_TYPE action, double& reward,
OBS_TYPE& obs) const {
Random random(random_num);
bool terminal = BaseTag::Step(state, random.NextDouble(), action, reward);
if (terminal) {
obs = same_loc_obs_;
} else {
if (rob_[state.state_id] == opp_[state.state_id])
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc(%rsp), %r13
movq %r13, %rdi
callq 0xd390
movq %r13, %rdi
callq 0xd710
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x100aa
m... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/laser_tag/laser_tag.cpp |
despot::LaserTag::ObsProb(unsigned long, despot::State const&, int) const | double LaserTag::ObsProb(OBS_TYPE obs, const State& state, ACT_TYPE action) const {
if (rob_[state.state_id] == opp_[state.state_id])
return obs == same_loc_obs_;
double prod = 1.0;
for (int dir = 0; dir < NBEAMS; dir++) {
int reading = GetReading(obs, dir);
if (reading >= LaserRange(state, dir) / unit_size_)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movslq 0xc(%rdx), %rax
movq 0xb0(%rdi), %rcx
movq 0xc8(%rdi), %rdx
movl (%rcx,%rax,4), %ecx
cmpl (%rdx,%rax,4), %ecx
jne 0x16f01
cmpq %rbx, 0xf8(%r15)
je 0x16fc4
xorpd %xmm0, %xmm0
jmp 0x16... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/laser_tag/laser_tag.cpp |
despot::LaserTag::InitialBelief(despot::State const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | Belief* LaserTag::InitialBelief(const State* start, string type) const {
//assert(start != NULL);
vector<State*> particles;
int N = floor_.NumCells();
double wgt = 1.0 / N / N;
for (int rob = 0; rob < N; rob++) {
for (int opp = 0; opp < N; opp++) {
TagState* state = static_cast<TagState*>(Allocate(
RobOp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x58(%rdi), %r14
movq %r14, %rdi
callq 0xd5e0
movl %eax, %ebp
testl %eax, %eax
jle 0x17168
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd 0x1f3c(%rip), %xm... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/laser_tag/laser_tag.cpp |
despot::operator<<(std::ostream&, despot::LaserTag const&) | ostream& operator<<(ostream& os, const LaserTag& lasertag) {
for (int s = 0; s < lasertag.NumStates(); s++) {
os << "State " << s << " " << lasertag.opp_[s] << " "
<< lasertag.rob_[s] << " " << lasertag.floor_.NumCells() << endl;
lasertag.PrintState(*lasertag.states_[s], os);
for (int d = 0; d < lasertag.NBE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
testl %eax, %eax
jle 0x1747b
leaq 0x58(%r14), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
leaq 0x1f46(%rip), %r12 # 0x191c5
movl $0x6, %edx
movq %r... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/laser_tag/laser_tag.cpp |
MyPlanner::InitializeModel(despot::option::Option*) | DSPOMDP* InitializeModel(option::Option* options) {
DSPOMDP* model = !options[E_PARAMS_FILE] ?
new LaserTag() : new LaserTag(options[E_PARAMS_FILE].arg);
return model;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq 0x70(%rsi), %r15
movl $0x180, %edi # imm = 0x180
callq 0xd3d0
movq %rax, %rbx
testq %r15, %r15
je 0x1805b
movq 0x80(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x17fbe
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x16aa6
j... | /AdaCompNUS[P]despot/examples/cpp_models/tag/src/laser_tag/main.cpp |
main | int main(int argc, char** argv){
args::ArgumentParser parser("********* IMRT-Solver *********", "An IMRT Solver.");
args::HelpFlag help(parser, "help", "Display this help menu", {'h', "help"});
//args::ValueFlag<string> _format(parser, "string", "Format: (BR, BRw, 1C)", {'f'});
//args::ValueFlag<double> _min_fr(pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6c8, %rsp # imm = 0x6C8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x17424(%rip), %rsi # 0x1d040
leaq 0x218(%rsp), %rdi
leaq 0x600(%rsp), %rdx
callq 0x5170
leaq 0x17428(%rip), %rsi # 0x1d060
leaq 0x148(%rsp), %rdi
leaq 0x3d0(%rsp), %... | /rilianx[P]IMRTsolver/main/test.cpp |
args::ArgumentParser::Help(std::ostream&) const | void Help(std::ostream &help_) const
{
bool hasoptions = false;
bool hasarguments = false;
const auto description_text = Wrap(this->description, helpParams.width - helpParams.descriptionindent);
const auto epilog_text = Wrap(this->epilog, help... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa8(%rdi), %rsi
movl 0x16c(%rdi), %edx
subl 0x178(%rdi), %edx
leaq 0xe8(%rsp), %rdi
xorl %ecx, %ecx
callq 0x58d7
leaq 0xc8(%r14), %rsi
movl 0x16c(%r14), %edx
subl 0x178(%r14... | /rilianx[P]IMRTsolver/main/args.hxx |
args::ArgumentParser::ArgumentParser(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&) | ArgumentParser(const std::string &description_, const std::string &epilog_ = std::string()) :
Group("", Group::Validators::AllChildGroups),
description(description_),
epilog(epilog_),
longprefix("--"),
shortprefix("-"),
long... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x16942(%rip), %rsi # 0x1db18
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rdx
callq 0x5170
leaq 0x38(%rsp), %rdx
andq $0x0, 0x8(%rdx)
leaq 0x1414(%rip), %rax # 0x860a
movq %rax, (... | /rilianx[P]IMRTsolver/main/args.hxx |
args::ArgumentParser::ParseCLI(int, char const* const*) | bool ParseCLI(const int argc, const char * const * argv)
{
if (prog.empty())
{
prog.assign(argv[0]);
}
const std::vector<std::string> args(argv + 1, argv + argc);
return ParseArgs(args) == std::end(args);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
jne 0x74cb
leaq 0x68(%rbx), %rdi
movq (%r14), %rsi
callq 0x5620
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
addq $0x8, %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %r... | /rilianx[P]IMRTsolver/main/args.hxx |
imrt::Station::revert(std::__cxx11::list<std::pair<int, double>, std::allocator<std::pair<int, double>>>&) | void revert(list< pair< int, double > >& diff){
for(auto let:diff){
pair <int,int> a = beam2pos[let.first];
change_intensity(a.first, a.second, I(a.first, a.second) - let.second);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x110(%rdi), %r15
movq %rsp, %r12
movq %rsi, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x76ee
movups 0x10(%r13), %xmm0
movaps %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xaf32
movslq (%rax), %rsi
movslq... | /rilianx[P]IMRTsolver/src/solution/Station.h |
imrt::Plan::~Plan() | virtual ~Plan() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x25541(%rip), %rax # 0x2cc48
movq %rax, (%rdi)
addq $0xb0, %rdi
callq 0xb5d4
leaq 0x98(%rbx), %rdi
callq 0xb5d4
leaq 0x80(%rbx), %rdi
callq 0xb5d4
leaq 0x60(%rbx), %rdi
callq 0xb1e8
leaq 0x38(%rbx), %rdi
callq 0xb322
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xb346
nop
| /rilianx[P]IMRTsolver/src/solution/Plan.h |
args::Group::GetPosNames[abi:cxx11]() const | std::vector<std::string> GetPosNames() const
{
std::vector <std::string> names;
for (const auto &child: children)
{
if (const Group *group = dynamic_cast<Group *>(child))
{
auto groupNames = group... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r15
leaq 0x24f0b(%rip), %r14 # 0x2c880
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x7a11
movq (%r12), %rbp
testq %rbp,... | /rilianx[P]IMRTsolver/main/args.hxx |
args::FlagBase::GetDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<c... | virtual std::tuple<std::string, std::string> GetDescription(const std::string &shortPrefix, const std::string &longPrefix, const std::string &, const std::string &) const override
{
std::tuple<std::string, std::string> description;
const auto flagStrings = matcher.GetFlagStri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
addq $0x30, %rdi
movq %rdi, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq %rsi, %r14
movb %al, 0x30(%rbx)... | /rilianx[P]IMRTsolver/main/args.hxx |
args::HelpFlag::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual FlagBase *Match(const std::string &arg) override
{
if (FlagBase::Match(arg))
{
#ifdef ARGS_NOEXCEPT
error = Error::Help;
return this;
#else
throw Help(arg);
#endif
}
return nul... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x9658
testq %rax, %rax
jne 0x951f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51d0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa012
leaq 0x232fc(%rip), %rsi # 0x2c838
movq 0x23a7d(%rip), %rdx # 0x2cfc0... | /rilianx[P]IMRTsolver/main/args.hxx |
args::HelpFlag::Match(char) | virtual FlagBase *Match(const char arg) override
{
if (FlagBase::Match(arg))
{
#ifdef ARGS_NOEXCEPT
error = Error::Help;
return this;
#else
throw Help(std::string(1, arg));
#endif
}
re... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
callq 0x974c
testq %rax, %rax
jne 0x957d
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51d0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bpl, %edx
movq %rsp, %rdi
pushq $0x1
popq... | /rilianx[P]IMRTsolver/main/args.hxx |
args::FlagBase::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual FlagBase *Match(const std::string &flag)
{
if (matcher.Match(flag))
{
if (extraError && matched)
{
#ifdef ARGS_NOEXCEPT
error = Error::Extra;
#else
std::ostringstream problem;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
addq $0x58, %rdi
callq 0x9d38
testb %al, %al
je 0x968b
cmpb $0x1, 0x51(%r14)
jne 0x9684
cmpb $0x1, 0x8(%r14)
je 0x969d
movb $0x1, 0x8(%r14)
jmp 0x968e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1a0, %rsp ... | /rilianx[P]IMRTsolver/main/args.hxx |
args::FlagBase::Match(char) | virtual FlagBase *Match(const char flag)
{
if (matcher.Match(flag))
{
if (extraError && matched)
{
#ifdef ARGS_NOEXCEPT
error = Error::Extra;
#else
std::ostringstream problem;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %esi, %ebx
movq %rdi, %r14
addq $0x58, %rdi
callq 0x9dda
testb %al, %al
je 0x977e
cmpb $0x1, 0x51(%r14)
jne 0x9777
cmpb $0x1, 0x8(%r14)
je 0x9790
movb $0x1, 0x8(%r14)
jmp 0x9781
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1a0, %rsp ... | /rilianx[P]IMRTsolver/main/args.hxx |
args::NamedBase::GetDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<... | virtual std::tuple<std::string, std::string> GetDescription(const std::string &, const std::string &, const std::string &, const std::string &) const override
{
std::tuple<std::string, std::string> description;
std::get<0>(description) = Name();
std::get<1>(de... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
movb %al, 0x30(%rdi)
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x28(%rax)
l... | /rilianx[P]IMRTsolver/main/args.hxx |
args::Matcher::GetFlagStrings(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::vector<std::string> GetFlagStrings(const std::string &shortPrefix, const std::string &longPrefix) const
{
std::vector<std::string> flagStrings;
flagStrings.reserve(shortFlags.size() + longFlags.size());
for (const char flag: shortFlags)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x50(%rsi), %rsi
addq 0x18(%r15), %rsi
callq 0x9f2a
leaq 0x10(%r15), %r14
leaq 0x8(%rsp), %r13
leaq 0x28... | /rilianx[P]IMRTsolver/main/args.hxx |
args::FlagBase* args::Group::Match<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | FlagBase *Match(const T &flag)
{
for (Base *child: children)
{
if (FlagBase *flagBase = dynamic_cast<FlagBase *>(child))
{
if (FlagBase *match = flagBase->Match(flag))
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r13
leaq 0x21c01(%rip), %r15 # 0x2c880
leaq 0x21c22(%rip), %r12 # 0x2c8a8
cmpq %r13, %rbx
je 0xace5
movq (%rbx), %rbp
testq %rbp, %rbp
je 0xacdf
movq %rbp, %rdi
movq %r15, %rsi
mo... | /rilianx[P]IMRTsolver/main/args.hxx |
args::FlagBase* args::Group::Match<char>(char const&) | FlagBase *Match(const T &flag)
{
for (Base *child: children)
{
if (FlagBase *flagBase = dynamic_cast<FlagBase *>(child))
{
if (FlagBase *match = flagBase->Match(flag))
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r13
leaq 0x21b57(%rip), %r15 # 0x2c880
leaq 0x21b78(%rip), %r12 # 0x2c8a8
cmpq %r13, %rbx
je 0xad90
movq (%rbx), %rbp
testq %rbp, %rbp
je 0xad8a
movq %rbp, %rdi
movq %r15, %rsi
mo... | /rilianx[P]IMRTsolver/main/args.hxx |
imrt::Station::initializeStation(int, int) | void Station::initializeStation(int type, int open_apertures) {
// Generating aperture patterns
if (type==OPEN_MAX_SETUP || type==OPEN_MIN_SETUP) {
for (int i=0; i<max_apertures; i++) {
vector<pair<int,int> > aux;
for (int j=0; j<collimator.getXdim(); j++){
aux.push_back(collim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
movl %esi, 0x2c(%rsp)
ja 0x10ace
xorl %r13d, %r13d
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movslq 0x40(%rbx), %rax
cmpq %rax, %r13
jge 0x10d00
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x20... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::Station(imrt::Station const&) | Station::Station(const Station &s): collimator(s.collimator){
collimator=s.collimator;
angle=s.angle;
max_apertures=s.max_apertures;
max_intensity=s.max_intensity;
min_intensity=s.min_intensity;
initial_intensity=s.initial_intensity;
step_intensity=s.step_intensity;
n_volumes=s.n_volumes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x1bd61(%rip), %rax # 0x2cd60
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
andl $0x0, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
leaq 0x10(%rdi),... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::operator=(imrt::Station const&) | Station& Station::operator=(const Station & s) {
collimator=s.collimator;
angle=s.angle;
max_apertures=s.max_apertures;
max_intensity=s.max_intensity;
min_intensity=s.min_intensity;
initial_intensity=s.initial_intensity;
step_intensity=s.step_intensity;
n_volumes=s.n_volumes;
for (in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0(%rsi), %rsi
movq 0xb0(%rdi), %rdi
callq 0x1709a
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movups 0x40(%r14), %xmm0
movups %xmm0, 0x40(%rbx)
movl 0x50(%r14), %eax
movl %eax, 0x50(%rbx)
movl 0x54(%... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::generate_random_intensities() | void Station::generate_random_intensities(){
clearIntensity();
vector<int> values(max_apertures+1);
values[0] = 0;
for(int i=1; i<max_apertures+1;i++){
int in=rand()%(max_intensity+1)/2.0;
values[i]=in;
}
for (int i=0; i < collimator.getXdim(); i++) {
list<int> in;
pair... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x115ba
movslq 0x40(%rbx), %rsi
incq %rsi
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0xe1de
movq (%r15), %rax
andl $0x0, (%rax)
pushq $0x1
popq %r15
movslq 0x40(%rbx), %rax
cmpq... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::clearIntensity() | void Station::clearIntensity() {
pair<int,int> aux;
for (int i=0; i < collimator.getXdim(); i++) {
aux = collimator.getActiveRange(i,angle);
if (aux.first<0) continue;
for (int j=aux.first; j<=aux.second; j++) I(i,j)=0;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0xb0(%rbx), %rdi
callq 0x1714a
cltq
cmpq %rax, %r14
jge 0x11617
movq 0xb0(%rbx), %rdi
movl 0x8(%rbx), %edx
movl %r14d, %esi
callq 0x174d6
testl %eax, %eax
js 0x11612
movq %rax, %rcx
shrq $0x20, %rcx
movq 0xc0(%rbx), %rdx
andl $0x7fffffff, %eax ... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::printIntensity(bool) | void Station::printIntensity(bool vector_form) {
if(!vector_form){
cout << "Angle "<< angle << endl;
cout << " aperture intensities: ";
cout << intensity[1];
for (int i=1;i<max_apertures;i++)
cout << ", " << intensity[i];
cout << endl <<" intensity matrix:"<< endl;
for (int i=0; i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x11b0c
xorl %r15d, %r15d
leaq 0xbddb(%rip), %r14 # 0x1d889
movq 0xb0(%rbx), %rdi
callq 0x1714a
cltq
cmpq %rax, %r15
jge 0x11c17
xorl %r12d, %r12d
movq 0xb0(%rbx), %rdi
callq 0x17152
cltq
cmpq %rax, %r12
jge 0x11b07
movq 0xc... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::increaseIntensity[abi:cxx11](int, double, int) | list< pair< int, double > > Station::increaseIntensity(int beam, double intensity, int ratio){
list< pair< int, double > > diff;
pair<int,int> p = getPos(beam);
int x=p.first, j=p.second;
for(int i=max(x-ratio,0); i<min(x+ratio+1,collimator.getXdim()); i++){
//for(int j=max(y-ratio,0); j<min(y+ratio+... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movapd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl %edx, %esi
callq 0x119d8
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
subl %ebp, %... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::closeBeamlet[abi:cxx11](int, int, bool) | list<pair <int,double> > Station::closeBeamlet(int beam, int aperture, bool lside) {
list<pair <int, double> > diff;
//cout << "Attempt to close beam: " << beam << " from left? " << lside << endl;
//cout << "active: " << isActiveBeamlet(beam) << "open: " << isOpenBeamlet(beam, aperture) << endl;
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq %rdi, 0x10(%rsp)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, 0x8(%rsp)
movl %edx, %esi
callq 0x1275c
testb %al, %al
je 0x1295e
movq %r14, %r... | /rilianx[P]IMRTsolver/src/solution/Station.cpp |
imrt::Station::~Station() | virtual ~Station(){ } | pushq %rbx
movq %rdi, %rbx
leaq 0x191d7(%rip), %rax # 0x2cd60
movq %rax, (%rdi)
addq $0x140, %rdi # imm = 0x140
callq 0xb450
leaq 0x110(%rbx), %rdi
callq 0xb3e4
leaq 0xe0(%rbx), %rdi
callq 0x13c08
leaq 0xc8(%rbx), %rdi
callq 0xb5d4
leaq 0xb8(%rbx), %rdi
callq 0x19c36
leaq 0x98(%rbx), %rdi
callq 0xb5d4
le... | /rilianx[P]IMRTsolver/src/solution/Station.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.