Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
mbedtls_camellia_setkey_enc
int mbedtls_camellia_setkey_enc( mbedtls_camellia_context *ctx, const unsigned char *key, unsigned int keybits ) { int idx; size_t i; uint32_t *RK; unsigned char t[64]; uint32_t SIGMA[6][2]; uint32_t KC[16]; uint32_t TK[20]; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x138, %rsp # imm = 0x138 movl %edx, %ebp movq %rsi, %r15 movq %rdi, %r14 leaq 0x4(%rdi), %rbx pxor %xmm0, %xmm0 movdqa %xmm0, 0xf0(%rsp) movdqa %xmm0, 0x100(%rsp) movdqa %xmm0, 0x110(%rsp) movdqa %xmm0, 0x120(%rsp) movl $0x110, %edx ...
/ARMmbed[P]mbed-crypto/library/camellia.c
mbedtls_camellia_crypt_cfb128
int mbedtls_camellia_crypt_cfb128( mbedtls_camellia_context *ctx, int mode, size_t length, size_t *iv_off, unsigned char iv[16], const unsigned char *input, unsigned char *output ) {...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, 0x8(%rsp) movq (%rcx), %rbp movl $0xffffffdc, %eax # imm = 0xFFFFFFDC cmpq $0xf, %rbp ja 0x176b6 movq %r9, %r14 movq %r8, %r15 movq %rdx, %r12 movq %rcx, 0x10(%rsp) movq 0x50(%rsp), %rbx testl %esi, %esi je 0x17670 testq...
/ARMmbed[P]mbed-crypto/library/camellia.c
mbedtls_camellia_crypt_ctr
int mbedtls_camellia_crypt_ctr( mbedtls_camellia_context *ctx, size_t length, size_t *nc_off, unsigned char nonce_counter[16], unsigned char stream_block[16], const unsigned char *input, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, 0x10(%rsp) movq (%rdx), %rbx movl $0xffffffdc, %eax # imm = 0xFFFFFFDC cmpq $0xf, %rbx ja 0x17755 movq %rsi, %r13 movq %rdx, 0x8(%rsp) testq %rsi, %rsi je 0x1774b movq %r9, %r14 movq %r8, %r15 movq %rcx, %r12 movq 0x50(%...
/ARMmbed[P]mbed-crypto/library/camellia.c
mbedtls_ccm_encrypt_and_tag
int mbedtls_ccm_encrypt_and_tag( mbedtls_ccm_context *ctx, size_t length, const unsigned char *iv, size_t iv_len, const unsigned char *add, size_t add_len, const unsigned char *input, unsigned char *output, unsigned char...
pushq %rax movq 0x28(%rsp), %r10 testq %r10, %r10 je 0x18237 movq %r9, %rax movq %r8, %r9 movq %rcx, %r8 movq %rdx, %rcx movq %rsi, %rdx subq $0x8, %rsp xorl %esi, %esi pushq %r10 pushq 0x30(%rsp) pushq 0x30(%rsp) pushq 0x30(%rsp) pushq %rax callq 0x17d86 addq $0x30, %rsp popq %rcx retq movl $0xfffffff3, %eax # i...
/ARMmbed[P]mbed-crypto/library/ccm.c
mbedtls_ccm_star_auth_decrypt
int mbedtls_ccm_star_auth_decrypt( mbedtls_ccm_context *ctx, size_t length, const unsigned char *iv, size_t iv_len, const unsigned char *add, size_t add_len, const unsigned char *input, unsigned char *output, const unsigned char *ta...
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %r9, %rax movq %r8, %r9 movq %rcx, %r8 movq %rdx, %rcx movq %rsi, %rbx movq 0x48(%rsp), %r15 movq 0x38(%rsp), %r14 subq $0x8, %rsp leaq 0x8(%rsp), %r10 movl $0x1, %esi movq %rbx, %rdx pushq %r15 pushq %r10 pushq %r14 pushq 0x50(%rsp) pushq %rax callq 0x17d86 addq $...
/ARMmbed[P]mbed-crypto/library/ccm.c
mbedtls_chacha20_starts
int mbedtls_chacha20_starts( mbedtls_chacha20_context* ctx, const unsigned char nonce[12], uint32_t counter ) { CHACHA20_VALIDATE_RET( ctx != NULL ); CHACHA20_VALIDATE_RET( nonce != NULL ); /* Counter */ ctx->state[12] = counter; /* Nonce *...
pushq %rbx movq %rdi, %rbx movl %edx, 0x30(%rdi) movl (%rsi), %eax movl %eax, 0x34(%rdi) movl 0x4(%rsi), %eax movl %eax, 0x38(%rdi) movl 0x8(%rsi), %eax movl %eax, 0x3c(%rdi) addq $0x40, %rdi movl $0x40, %esi callq 0x27260 movq $0x40, 0x80(%rbx) xorl %eax, %eax popq %rbx retq
/ARMmbed[P]mbed-crypto/library/chacha20.c
mbedtls_chachapoly_starts
int mbedtls_chachapoly_starts( mbedtls_chachapoly_context *ctx, const unsigned char nonce[12], mbedtls_chachapoly_mode_t mode ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; unsigned char poly1305_key[64]; CHACHAPOLY_VALIDATE_RET( ctx != NU...
pushq %rbp pushq %r14 pushq %rbx subq $0x40, %rsp movl %edx, %ebx movq %rdi, %r14 xorl %edx, %edx callq 0x185a9 testl %eax, %eax jne 0x18ce2 xorps %xmm0, %xmm0 movq %rsp, %rcx movaps %xmm0, 0x30(%rcx) movaps %xmm0, 0x20(%rcx) movaps %xmm0, 0x10(%rcx) movaps %xmm0, (%rcx) movl $0x40, %esi movq %r14, %rdi movq %rcx, %rdx...
/ARMmbed[P]mbed-crypto/library/chachapoly.c
mbedtls_chachapoly_update
int mbedtls_chachapoly_update( mbedtls_chachapoly_context *ctx, size_t len, const unsigned char *input, unsigned char *output ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; CHACHAPOLY_VALIDATE_RET( ctx != NULL ); ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %rbx movq %rdx, %r12 movl 0xe8(%rdi), %ecx leal -0x1(%rcx), %edx movl $0xffffffac, %eax # imm = 0xFFFFFFAC cmpl $0x1, %edx ja 0x18e18 movq %rsi, %r14 movq %rdi, %r15 cmpl $0x1, %ecx jne 0x18dae movl $0x2, 0xe8(%r15) movl 0xd8(%r15), %eax andl...
/ARMmbed[P]mbed-crypto/library/chachapoly.c
mbedtls_chachapoly_encrypt_and_tag
int mbedtls_chachapoly_encrypt_and_tag( mbedtls_chachapoly_context *ctx, size_t length, const unsigned char nonce[12], const unsigned char *aad, size_t aad_len,...
subq $0x18, %rsp movq %r8, %rax movq %rcx, %r8 movq %rdx, %rcx movq %rsi, %rdx movaps 0x20(%rsp), %xmm0 movups %xmm0, 0x8(%rsp) movq %r9, (%rsp) xorl %esi, %esi movq %rax, %r9 callq 0x18f02 addq $0x18, %rsp retq
/ARMmbed[P]mbed-crypto/library/chachapoly.c
mbedtls_cipher_info_from_string
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name ) { const mbedtls_cipher_definition_t *def; if( NULL == cipher_name ) return( NULL ); for( def = mbedtls_cipher_definitions; def->info != NULL; def++ ) if( ! strcmp( def->info->name, cipher_name ) ) ...
pushq %r15 pushq %r14 pushq %rbx testq %rdi, %rdi je 0x192b0 leaq 0x313fc(%rip), %r15 # 0x4a680 movq 0x8(%r15), %rbx testq %rbx, %rbx je 0x192b0 movq %rdi, %r14 addq $0x18, %r15 movq 0x10(%rbx), %rdi movq %r14, %rsi callq 0xb130 testl %eax, %eax je 0x192b2 movq (%r15), %rbx addq $0x10, %r15 testq %rbx, %rbx jne 0x1...
/ARMmbed[P]mbed-crypto/library/cipher.c
mbedtls_cipher_free
void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx ) { if( ctx == NULL ) return; #if defined(MBEDTLS_USE_PSA_CRYPTO) if( ctx->psa_enabled == 1 ) { if( ctx->cipher_ctx != NULL ) { mbedtls_cipher_context_psa * const cipher_psa = (mbedtls_cipher_context...
testq %rdi, %rdi je 0x19352 pushq %rbx movq %rdi, %rbx movq 0x58(%rdi), %rdi testq %rdi, %rdi je 0x19331 movl $0x28, %esi callq 0x27260 movq 0x58(%rbx), %rdi callq 0xb030 movq 0x50(%rbx), %rdi testq %rdi, %rdi je 0x19344 movq (%rbx), %rax movq 0x28(%rax), %rax callq *0x58(%rax) movl $0x60, %esi movq %rbx, %rdi popq %rb...
/ARMmbed[P]mbed-crypto/library/cipher.c
mbedtls_cipher_reset
int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx ) { CIPHER_VALIDATE_RET( ctx != NULL ); if( ctx->cipher_info == NULL ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); #if defined(MBEDTLS_USE_PSA_CRYPTO) if( ctx->psa_enabled == 1 ) { /* We don't support resetting PSA-based ...
cmpq $0x0, (%rdi) je 0x194e2 movq $0x0, 0x30(%rdi) xorl %eax, %eax retq movl $0xffff9f00, %eax # imm = 0xFFFF9F00 retq
/ARMmbed[P]mbed-crypto/library/cipher.c
mbedtls_cipher_update_ad
int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx, const unsigned char *ad, size_t ad_len ) { CIPHER_VALIDATE_RET( ctx != NULL ); CIPHER_VALIDATE_RET( ad_len == 0 || ad != NULL ); if( ctx->cipher_info == NULL ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); #if defined...
pushq %r15 pushq %r14 pushq %rbx movq (%rdi), %rcx testq %rcx, %rcx je 0x19527 movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 cmpl $0x6, 0x4(%rcx) jne 0x1952e movq 0x50(%r15), %rdi movl 0xc(%r15), %esi movq 0x48(%r15), %rcx addq $0x38, %r15 movq %r15, %rdx movq %r14, %r8 movq %rbx, %r9 popq %rbx popq %r14 popq %r15 jm...
/ARMmbed[P]mbed-crypto/library/cipher.c
mbedtls_cipher_update
int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; size_t block_size; CIPHER_VALIDATE_RET( ctx != NULL ); CIPHER_VALIDATE_RET( ilen == 0 || input !...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %r12 movq (%rdi), %rcx movl $0xffff9f00, %ebp # imm = 0xFFFF9F00 testq %rcx, %rcx je 0x195e9 movq %r8, %r14 movq $0x0, (%r8) movl 0x20(%rcx), %r15d testq %r15, %r15 je 0x195e4 movq %rdx, %rbx movq %rsi, %r9 movq %rdi, %r...
/ARMmbed[P]mbed-crypto/library/cipher.c
get_zeros_and_len_padding
static int get_zeros_and_len_padding( unsigned char *input, size_t input_len, size_t *data_len ) { size_t i, pad_idx; unsigned char padding_len, bad = 0; if( NULL == input || NULL == data_len ) return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); padding_len = inp...
testq %rdi, %rdi sete %al testq %rdx, %rdx sete %cl orb %al, %cl movl $0xffff9f00, %eax # imm = 0xFFFF9F00 jne 0x19b7f leaq -0x1(%rsi), %rax movzbl -0x1(%rdi,%rsi), %ecx testq %rcx, %rcx sete %r8b subq %rcx, %rsi setb %cl movq %rsi, (%rdx) orb %r8b, %cl testq %rax, %rax je 0x19b73 xorl %edx, %edx xorl %r8d, %r8d ...
/ARMmbed[P]mbed-crypto/library/cipher.c
camellia_ctx_alloc
static void * camellia_ctx_alloc( void ) { mbedtls_camellia_context *ctx; ctx = mbedtls_calloc( 1, sizeof( mbedtls_camellia_context ) ); if( ctx == NULL ) return( NULL ); mbedtls_camellia_init( ctx ); return( ctx ); }
pushq %rbx movl $0x1, %edi movl $0x114, %esi # imm = 0x114 callq 0xb120 movq %rax, %rbx testq %rax, %rax je 0x1a155 movq %rbx, %rdi callq 0x16864 movq %rbx, %rax popq %rbx retq
/ARMmbed[P]mbed-crypto/library/cipher_wrap.c
chacha20_ctx_alloc
static void * chacha20_ctx_alloc( void ) { mbedtls_chacha20_context *ctx; ctx = mbedtls_calloc( 1, sizeof( mbedtls_chacha20_context ) ); if( ctx == NULL ) return( NULL ); mbedtls_chacha20_init( ctx ); return( ctx ); }
pushq %rbx movl $0x1, %edi movl $0x88, %esi callq 0xb120 movq %rax, %rbx testq %rax, %rax je 0x1a28d movq %rbx, %rdi callq 0x18534 movq %rbx, %rax popq %rbx retq
/ARMmbed[P]mbed-crypto/library/cipher_wrap.c
chachapoly_ctx_alloc
static void * chachapoly_ctx_alloc( void ) { mbedtls_chachapoly_context *ctx; ctx = mbedtls_calloc( 1, sizeof( mbedtls_chachapoly_context ) ); if( ctx == NULL ) return( NULL ); mbedtls_chachapoly_init( ctx ); return( ctx ); }
pushq %rbx movl $0x1, %edi movl $0xf0, %esi callq 0xb120 movq %rax, %rbx testq %rax, %rax je 0x1a2e8 movq %rbx, %rdi callq 0x18c2c movq %rbx, %rax popq %rbx retq
/ARMmbed[P]mbed-crypto/library/cipher_wrap.c
mbedtls_cmac_self_test
int mbedtls_cmac_self_test( int verbose ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; #if defined(MBEDTLS_AES_C) /* AES-128 */ if( ( ret = cmac_test_subkeys( verbose, "AES 128", aes_128_key, 128,...
pushq %rbp pushq %rbx pushq %rax movl %edi, %ebx subq $0x8, %rsp leaq 0x1e31f(%rip), %rsi # 0x38bcc leaq 0x1e39c(%rip), %rdx # 0x38c50 leaq 0x1e3a5(%rip), %r8 # 0x38c60 movl $0x80, %ecx movl $0x2, %r9d pushq $0x10 callq 0x1aaf1 addq $0x10, %rsp testl %eax, %eax jne 0x1aad4 leaq 0x1e2ec(%rip), %rsi # 0x...
/ARMmbed[P]mbed-crypto/library/cmac.c
mbedtls_ctr_drbg_free
void mbedtls_ctr_drbg_free( mbedtls_ctr_drbg_context *ctx ) { if( ctx == NULL ) return; #if defined(MBEDTLS_THREADING_C) mbedtls_mutex_free( &ctx->mutex ); #endif mbedtls_aes_free( &ctx->aes_ctx ); mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ctr_drbg_context ) ); }
testq %rdi, %rdi je 0x1aef5 pushq %rbx movq %rdi, %rbx addq $0x28, %rdi callq 0xf498 movl $0x158, %esi # imm = 0x158 movq %rbx, %rdi popq %rbx jmp 0x27260 retq
/ARMmbed[P]mbed-crypto/library/ctr_drbg.c
mbedtls_ctr_drbg_seed
int mbedtls_ctr_drbg_seed( mbedtls_ctr_drbg_context *ctx, int (*f_entropy)(void *, unsigned char *, size_t), void *p_entropy, const unsigned char *custom, size_t len ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %r8, %rbx movq %rcx, %r14 movq %rdx, %r13 movq %rsi, %rbp movq %rdi, %r15 xorps %xmm0, %xmm0 movaps %xmm0, 0x10(%rsp) movaps %xmm0, (%rsp) leaq 0x28(%rdi), %r12 movq %r12, %rdi callq 0xf48c movq %rbp, 0x148(%r15) movq %r13, 0x150(%r...
/ARMmbed[P]mbed-crypto/library/ctr_drbg.c
mbedtls_ctr_drbg_write_seed_file
int mbedtls_ctr_drbg_write_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path ) { int ret = MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR; FILE *f; unsigned char buf[ MBEDTLS_CTR_DRBG_MAX_INPUT ]; if( ( f = fopen( path, "wb" ) ) == NULL ) return( MBEDTLS_ERR_C...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x108, %rsp # imm = 0x108 movq %rsi, %rax movq %rdi, %r14 leaq 0x1d9d6(%rip), %rsi # 0x38f80 movq %rax, %rdi callq 0xb1b0 testq %rax, %rax je 0x1b613 movq %rax, %rbx xorl %r15d, %r15d movq %rsp, %rsi movl $0x100, %edx # imm = 0x100 movq %r14, %...
/ARMmbed[P]mbed-crypto/library/ctr_drbg.c
mbedtls_des_setkey_dec
int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] ) { int i; mbedtls_des_setkey( ctx->sk, key ); for( i = 0; i < 16; i += 2 ) { SWAP( ctx->sk[i ], ctx->sk[30 - i] ); SWAP( ctx->sk[i + 1], ctx->sk[31 - i] ); } return( 0 ); }
pushq %rbx movq %rdi, %rbx callq 0x1ba29 leaq 0x7c(%rbx), %rax movq $-0x2, %rcx movl 0x8(%rbx,%rcx,4), %edx movl -0x4(%rax), %esi movl %esi, 0x8(%rbx,%rcx,4) movl %edx, -0x4(%rax) movl 0xc(%rbx,%rcx,4), %edx movl (%rax), %esi movl %esi, 0xc(%rbx,%rcx,4) movl %edx, (%rax) addq $0x2, %rcx addq $-0x8, %rax cmpq $0xe, %rcx...
/ARMmbed[P]mbed-crypto/library/des.c
des3_set2key
static void des3_set2key( uint32_t esk[96], uint32_t dsk[96], const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] ) { int i; mbedtls_des_setkey( esk, key ); mbedtls_des_setkey( dsk + 32, key + 8 ); for( i = 0; i < 32; i += 2 ) { dsk[i ] =...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movq %rdx, %rsi callq 0x1ba29 leaq 0x80(%rbx), %rdi addq $0x8, %r15 movq %r15, %rsi callq 0x1ba29 movl $0x40, %ecx movl $0x3f, %eax movl -0x84(%r14,%rax,4), %edx movl %edx, -0x100(%rbx,%rcx,4) movl -0x80(%r14,%rax,4), %edx movl %edx, -0xfc...
/ARMmbed[P]mbed-crypto/library/des.c
des3_set3key
static void des3_set3key( uint32_t esk[96], uint32_t dsk[96], const unsigned char key[24] ) { int i; mbedtls_des_setkey( esk, key ); mbedtls_des_setkey( dsk + 32, key + 8 ); mbedtls_des_setkey( esk + 64, key + 16 ); for( i = 0; i < 32; i += 2 ) ...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movq %rdx, %rsi callq 0x1ba29 leaq 0x80(%rbx), %rdi leaq 0x8(%r15), %rsi callq 0x1ba29 leaq 0x100(%r14), %rdi addq $0x10, %r15 movq %r15, %rsi callq 0x1ba29 movq $-0x2, %rax movl $0x3e, %ecx movl 0x80(%r14,%rcx,4), %edx movl %edx, 0x8(%rbx...
/ARMmbed[P]mbed-crypto/library/des.c
mbedtls_dhm_read_params
int mbedtls_dhm_read_params( mbedtls_dhm_context *ctx, unsigned char **p, const unsigned char *end ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; DHM_VALIDATE_RET( ctx != NULL ); DHM_VALIDATE_RET( p != NULL && *p != NULL ); DHM_VALIDATE_RET( end != NULL );...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %rbx leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0x1ce21 testl %eax, %eax jne 0x1ce17 leaq 0x20(%rbx), %rdi movq %r12, %rsi movq %r15, %rdx callq 0x1ce21 testl %eax, %eax jne 0x1ce17 leaq 0x68(%rbx), %r13 movq %r13, %rdi mo...
/ARMmbed[P]mbed-crypto/library/dhm.c
mbedtls_dhm_parse_dhmfile
int mbedtls_dhm_parse_dhmfile( mbedtls_dhm_context *dhm, const char *path ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; size_t n; unsigned char *buf; DHM_VALIDATE_RET( dhm != NULL ); DHM_VALIDATE_RET( path != NULL ); if( ( ret = load_file( path, &buf, &n ) ) != 0 ) return( ret );...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rax movq %rdi, %r14 leaq 0x1b7df(%rip), %rsi # 0x38f83 movq %rax, %rdi callq 0xb1b0 movl $0xffffcb80, %ebx # imm = 0xFFFFCB80 testq %rax, %rax je 0x1d885 movq %rax, %r15 movq %rax, %rdi xorl %esi, %esi movl $0x2, %edx cal...
/ARMmbed[P]mbed-crypto/library/dhm.c
mbedtls_ecdh_compute_shared
int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z, const mbedtls_ecp_point *Q, const mbedtls_mpi *d, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { ECDH_VALIDATE_RET( grp != NULL ); ECDH_VALIDATE_RET...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %r9, %r14 movq %r8, %r15 movq %rcx, %r12 movq %rdx, %r13 movq %rsi, 0x8(%rsp) movq %rdi, %rbp leaq 0x10(%rsp), %rbx movq %rbx, %rdi callq 0x1ea07 movq $0x0, (%rsp) movq %rbp, %rdi movq %rbx, %rsi movq %r12, %rdx movq %r13, %rcx movq...
/ARMmbed[P]mbed-crypto/library/ecdh.c
mbedtls_ecdh_init
void mbedtls_ecdh_init( mbedtls_ecdh_context *ctx ) { ECDH_VALIDATE( ctx != NULL ); #if defined(MBEDTLS_ECDH_LEGACY_CONTEXT) ecdh_init_internal( ctx ); mbedtls_ecp_point_init( &ctx->Vi ); mbedtls_ecp_point_init( &ctx->Vf ); mbedtls_mpi_init( &ctx->_d ); #else memset( ctx, 0, sizeof( mbedtls_e...
pushq %rbx movq %rdi, %rbx callq 0x1ea26 leaq 0xf8(%rbx), %rdi callq 0x12024 leaq 0x110(%rbx), %rdi callq 0x1ea07 leaq 0x158(%rbx), %rdi callq 0x1ea07 leaq 0x1a0(%rbx), %rdi callq 0x12024 leaq 0x1c0(%rbx), %rdi callq 0x1ea07 leaq 0x208(%rbx), %rdi callq 0x1ea07 leaq 0x250(%rbx), %rdi callq 0x12024 movl $0x0, 0x1b8(%rbx...
/ARMmbed[P]mbed-crypto/library/ecdh.c
mbedtls_ecdh_read_params
int mbedtls_ecdh_read_params( mbedtls_ecdh_context *ctx, const unsigned char **buf, const unsigned char *end ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; mbedtls_ecp_group_id grp_id; ECDH_VALIDATE_RET( ctx != NULL ); ECDH_VALIDATE_RET( ...
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 subq (%rsi), %rdx leaq 0xc(%rsp), %rdi callq 0x1f09d testl %eax, %eax jne 0x1dc0d movl 0xc(%rsp), %esi movq %r15, %rdi callq 0x2205c movl %eax, %ecx movl $0xffffb180, %eax # imm = 0xFFFFB180 testl %ecx, %ecx jne 0x1d...
/ARMmbed[P]mbed-crypto/library/ecdh.c
mbedtls_ecdsa_can_do
int mbedtls_ecdsa_can_do( mbedtls_ecp_group_id gid ) { switch( gid ) { #ifdef MBEDTLS_ECP_DP_CURVE25519_ENABLED case MBEDTLS_ECP_DP_CURVE25519: return 0; #endif #ifdef MBEDTLS_ECP_DP_CURVE448_ENABLED case MBEDTLS_ECP_DP_CURVE448: return 0; #endif default: return 1; } }
addl $-0x9, %edi xorl %eax, %eax testl $0xfffffffb, %edi # imm = 0xFFFFFFFB setne %al retq
/ARMmbed[P]mbed-crypto/library/ecdsa.c
mbedtls_ecdsa_sign_det
int mbedtls_ecdsa_sign_det( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, mbedtls_md_type_t md_alg ) { ECDSA_VALIDATE_RET( grp != NULL ); ECDSA_VALIDATE_RE...
subq $0x18, %rsp movl 0x20(%rsp), %eax xorps %xmm0, %xmm0 movups %xmm0, 0x8(%rsp) movl %eax, (%rsp) callq 0x1e16b addq $0x18, %rsp retq
/ARMmbed[P]mbed-crypto/library/ecdsa.c
ecdsa_sign_det_restartable
static int ecdsa_sign_det_restartable( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s, const mbedtls_mpi *d, const unsigned char *buf, size_t blen, mbedtls_md_type_t md_alg, int (*f_rng_blind)(void *, unsigned char *, size_t), ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1b8, %rsp # imm = 0x1B8 movq %r9, %rbx movq %r8, %r14 movq %rcx, %r15 movq %rdx, 0x10(%rsp) movq %rsi, 0x8(%rsp) movq %rdi, %rbp movl 0x1f0(%rsp), %edi movq 0xb8(%rbp), %r12 callq 0x2537c testq %rax, %rax je 0x1e295 movq %rax, %r13 mov...
/ARMmbed[P]mbed-crypto/library/ecdsa.c
ecdsa_verify_restartable
static int ecdsa_verify_restartable( mbedtls_ecp_group *grp, const unsigned char *buf, size_t blen, const mbedtls_ecp_point *Q, const mbedtls_mpi *r, const mbedtls_mpi *s, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xd8, %rsp movq %r9, %rbp movq %r8, %r14 movq %rcx, 0x28(%rsp) movq %rdx, %r13 movq %rsi, %r15 movq %rdi, %r12 leaq 0x90(%rsp), %rdi callq 0x1ea07 leaq 0x78(%rsp), %rdi callq 0x12024 leaq 0x60(%rsp), %rdi callq 0x12024 leaq 0x48(%rsp), %rdi callq 0...
/ARMmbed[P]mbed-crypto/library/ecdsa.c
mbedtls_ecp_curve_info_from_name
const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_name( const char *name ) { const mbedtls_ecp_curve_info *curve_info; if( name == NULL ) return( NULL ); for( curve_info = mbedtls_ecp_curve_list(); curve_info->grp_id != MBEDTLS_ECP_DP_NONE; curve_info++ ) { if...
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x1e9e5 movq %rdi, %r14 leaq 0x2c565(%rip), %rbx # 0x4af30 movq 0x8(%rbx), %rdi movq %r14, %rsi callq 0xb130 testl %eax, %eax je 0x1e9e7 cmpl $0x0, 0x10(%rbx) leaq 0x10(%rbx), %rbx jne 0x1e9cb xorl %ebx, %ebx movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 re...
/ARMmbed[P]mbed-crypto/library/ecp.c
mbedtls_ecp_copy
int mbedtls_ecp_copy( mbedtls_ecp_point *P, const mbedtls_ecp_point *Q ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; ECP_VALIDATE_RET( P != NULL ); ECP_VALIDATE_RET( Q != NULL ); MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->X, &Q->X ) ); MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Y, &Q->Y ) ); MBE...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 callq 0x121c0 testl %eax, %eax jne 0x1ec23 leaq 0x18(%r14), %rdi leaq 0x18(%rbx), %rsi callq 0x121c0 testl %eax, %eax je 0x1ec2b addq $0x8, %rsp popq %rbx popq %r14 retq addq $0x30, %r14 addq $0x30, %rbx movq %r14, %rdi movq %rbx, %rsi addq $0x8, %rsp pop...
/ARMmbed[P]mbed-crypto/library/ecp.c
ecp_randomize_mxz
static int ecp_randomize_mxz( const mbedtls_ecp_group *grp, mbedtls_ecp_point *P, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; mbedtls_mpi l; size_t p_size; int count = 0; #if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT) i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rcx, %r14 movq %rdx, %r12 movq %rsi, 0x18(%rsp) movq %rdi, %rbx movq 0xb0(%rdi), %r13 addq $0x7, %r13 shrq $0x3, %r13 leaq 0x20(%rsp), %rbp movq %rbp, %rdi callq 0x12024 movq %rbx, 0x10(%rsp) addq $0x8, %rbx movl $0x0, 0xc(%rsp) mo...
/ARMmbed[P]mbed-crypto/library/ecp.c
ecp_mod_koblitz
static inline int ecp_mod_koblitz( mbedtls_mpi *N, mbedtls_mpi_uint *Rp, size_t p_limbs, size_t adjust, size_t shift, mbedtls_mpi_uint mask ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; size_t i; mbedtls_mpi M, R; mbedtls_mpi_uint Mp[P_KOBLITZ_MAX + P_KOBLITZ_R ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq 0x8(%rdi), %r12 xorl %eax, %eax cmpq %rdx, %r12 jb 0x237e2 movq %rcx, %r13 movq %rdx, %r14 movq %rdi, %rbx movq %r9, 0x20(%rsp) movl $0x1, %eax movl %eax, 0x38(%rsp) movq %rsi, 0x48(%rsp) movq $0x1, 0x40(%rsp) movl %eax, 0x8(%rsp) l...
/ARMmbed[P]mbed-crypto/library/ecp_curves.c
mbedtls_hmac_drbg_update_ret
int mbedtls_hmac_drbg_update_ret( mbedtls_hmac_drbg_context *ctx, const unsigned char *additional, size_t add_len ) { size_t md_len = mbedtls_md_get_size( ctx->md_ctx.md_info ); unsigned char rounds = ( additional != NULL && add_len != 0 ) ? 2 ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq (%rdi), %rdi callq 0x25bd1 movzbl %al, %r12d movq %r14, 0x10(%rsp) testq %r14, %r14 setne %al movq %rbx, 0x18(%rsp) testq %rbx, %rbx setne %r14b andb %al, %r14b leaq 0x18(%r15), %r13 l...
/ARMmbed[P]mbed-crypto/library/hmac_drbg.c
mbedtls_hmac_drbg_self_test
int mbedtls_hmac_drbg_self_test( int verbose ) { mbedtls_hmac_drbg_context ctx; unsigned char buf[OUTPUT_LEN]; const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ); mbedtls_hmac_drbg_init( &ctx ); /* * PR = True */ if( verbose != 0 ) mbedtls_printf(...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0xd8, %rsp movl %edi, %ebx movl $0x4, %edi callq 0x2537c movq %rax, %r14 xorps %xmm0, %xmm0 movaps %xmm0, (%rsp) movaps %xmm0, 0x10(%rsp) movaps %xmm0, 0x20(%rsp) movaps %xmm0, 0x30(%rsp) movaps %xmm0, 0x40(%rsp) movaps %xmm0, 0x50(%rsp) movaps %xmm0, 0x60(%rsp) movaps ...
/ARMmbed[P]mbed-crypto/library/hmac_drbg.c
mbedtls_md_process
int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data ) { if( ctx == NULL || ctx->md_info == NULL ) return( MBEDTLS_ERR_MD_BAD_INPUT_DATA ); switch( ctx->md_info->type ) { #if defined(MBEDTLS_MD2_C) case MBEDTLS_MD_MD2: return( mbedtls_internal_md2_process...
testq %rdi, %rdi je 0x25ba7 movq (%rdi), %rax testq %rax, %rax je 0x25ba7 movl 0x8(%rax), %eax addl $-0x3, %eax cmpl $0x6, %eax ja 0x25ba7 leaq 0x15bdf(%rip), %rcx # 0x3b774 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movq 0x8(%rdi), %rdi jmp 0x2e0c7 movl $0xffffaf00, %eax # imm = 0xFFFFAF00 retq mo...
/ARMmbed[P]mbed-crypto/library/md.c
mbedtls_md5_starts_ret
int mbedtls_md5_starts_ret( 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; return( 0 ); }
movaps 0x15b8a(%rip), %xmm0 # 0x3b7c0 movups %xmm0, (%rdi) movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE movq %rax, 0x10(%rdi) xorl %eax, %eax retq
/ARMmbed[P]mbed-crypto/library/md5.c
pem_des3_decrypt
static int pem_des3_decrypt( unsigned char des3_iv[8], unsigned char *buf, size_t buflen, const unsigned char *pwd, size_t pwdlen ) { mbedtls_des3_context des3_ctx; unsigned char des3_key[24]; int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; mbe...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x198, %rsp # imm = 0x198 movq %r8, %r12 movq %rcx, %r13 movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %r15 leaq 0x18(%rsp), %rdi callq 0x1b99f movq %rsp, %rdi movl $0x18, %esi movq %r15, %rdx movq %r13, %rcx movq %r12, %r8 callq 0x27119 te...
/ARMmbed[P]mbed-crypto/library/pem.c
mbedtls_ripemd160_ret
int mbedtls_ripemd160_ret( const unsigned char *input, size_t ilen, unsigned char output[20] ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; mbedtls_ripemd160_context ctx; mbedtls_ripemd160_init( &ctx ); if( ( ret = mbedtls_ripemd160_starts_re...
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 0x1271d(%rip), %xmm0 # 0x3b7d0 movups %xmm...
/ARMmbed[P]mbed-crypto/library/ripemd160.c
mbedtls_rsa_public
int mbedtls_rsa_public( mbedtls_rsa_context *ctx, const unsigned char *input, unsigned char *output ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; size_t olen; mbedtls_mpi T; RSA_VALIDATE_RET( ctx != NULL ); RSA_VALIDATE_RET( input != NULL ); RSA_VALIDATE_RE...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 xorl %esi, %esi callq 0x295b9 movl $0xffffbf80, %ebp # imm = 0xFFFFBF80 testl %eax, %eax jne 0x2a017 leaq 0x8(%rsp), %r12 movq %r12, %rdi callq 0x12024 movq 0x8(%r14), %rdx movq %r12, %rdi movq ...
/ARMmbed[P]mbed-crypto/library/rsa.c
mbedtls_rsa_rsassa_pss_verify
int mbedtls_rsa_rsassa_pss_verify( mbedtls_rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, mbedtls_md_type_t md_alg, unsigned int hashlen, ...
pushq %rax movl 0x14c(%rdi), %eax testl %eax, %eax cmovel %r8d, %eax pushq 0x18(%rsp) pushq $-0x1 pushq %rax pushq 0x28(%rsp) callq 0x2b68a addq $0x20, %rsp popq %rcx retq
/ARMmbed[P]mbed-crypto/library/rsa.c
mbedtls_rsa_pkcs1_verify
int mbedtls_rsa_pkcs1_verify( mbedtls_rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, mbedtls_md_type_t md_alg, unsigned int hashlen, const unsigned...
movl 0x148(%rdi), %eax cmpl $0x1, %eax je 0x2bacf testl %eax, %eax jne 0x2baf2 jmp 0x2b98e pushq %rax movl 0x14c(%rdi), %eax testl %eax, %eax cmovel %r8d, %eax pushq 0x18(%rsp) pushq $-0x1 pushq %rax pushq 0x28(%rsp) callq 0x2b68a addq $0x20, %rsp popq %rcx retq movl $0xffffbf00, %eax # imm = 0xFFFFBF00 retq
/ARMmbed[P]mbed-crypto/library/rsa.c
mbedtls_rsa_copy
int mbedtls_rsa_copy( mbedtls_rsa_context *dst, const mbedtls_rsa_context *src ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; RSA_VALIDATE_RET( dst != NULL ); RSA_VALIDATE_RET( src != NULL ); dst->ver = src->ver; dst->len = src->len; MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->N, &src->N ) ...
pushq %rbp pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx movl (%rsi), %eax movl %eax, (%rdi) movq 0x8(%rsi), %rax movq %rax, 0x8(%rdi) addq $0x10, %rdi addq $0x10, %rsi callq 0x121c0 testl %eax, %eax jne 0x2bc23 leaq 0x28(%rbx), %rdi leaq 0x28(%r14), %rsi callq 0x121c0 testl %eax, %eax jne 0x2bc23 leaq 0x40(%rb...
/ARMmbed[P]mbed-crypto/library/rsa.c
mbedtls_sha1_finish_ret
int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx, unsigned char output[20] ) { int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; uint32_t used; uint32_t high, low; SHA1_VALIDATE_RET( ctx != NULL ); SHA1_VALIDATE_RET( (unsigned char *)output != NULL ); /* ...
pushq %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %rbp movl (%rdi), %edx andl $0x3f, %edx leaq 0x1c(%rdi), %r14 addq %rdx, %rdi addq $0x1d, %rdi movb $-0x80, -0x1(%rdi) cmpl $0x37, %edx ja 0x2dd10 movl $0x37, %eax subl %edx, %eax xorl %esi, %esi movq %rax, %rdx callq 0xb0e0 jmp 0x2dd3e xorl $0x3f, %edx xorl %...
/ARMmbed[P]mbed-crypto/library/sha1.c
mbedtls_sha256_starts_ret
int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 ) { SHA256_VALIDATE_RET( ctx != NULL ); SHA256_VALIDATE_RET( is224 == 0 || is224 == 1 ); ctx->total[0] = 0; ctx->total[1] = 0; if( is224 == 0 ) { /* SHA-256 */ ctx->state[0] = 0x6A09E667; ctx->state[1...
movq $0x0, (%rdi) testl %esi, %esi je 0x2e070 movaps 0xe66b(%rip), %xmm0 # 0x3c6d0 jne 0x2e079 movaps 0xe672(%rip), %xmm1 # 0x3c6e0 jmp 0x2e080 movaps 0xe649(%rip), %xmm0 # 0x3c6c0 je 0x2e067 movaps 0xe670(%rip), %xmm1 # 0x3c6f0 movups %xmm0, 0x8(%rdi) movups %xmm1, 0x18(%rdi) movl %esi, 0x68(%rdi) xorl...
/ARMmbed[P]mbed-crypto/library/sha256.c
mbedtls_internal_sha512_process
int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx, const unsigned char data[128] ) { int i; uint64_t temp1, temp2, W[80]; uint64_t A[8]; SHA512_VALIDATE_RET( ctx != NULL ); SHA512_VALIDATE_RET( (const unsigned char *)data != NULL ); #define SHR(...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x258, %rsp # imm = 0x258 leaq 0x10(%rdi), %rax movdqu 0x10(%rdi), %xmm0 movups 0x20(%rdi), %xmm1 movups 0x30(%rdi), %xmm2 movups 0x40(%rdi), %xmm3 movaps %xmm3, -0x50(%rsp) movaps %xmm2, -0x60(%rsp) movaps %xmm1, -0x70(%rsp) movdqa %xmm...
/ARMmbed[P]mbed-crypto/library/sha512.c
mbedtls_base64_decode
int mbedtls_base64_decode( unsigned char *dst, size_t dlen, size_t *olen, const unsigned char *src, size_t slen ) { size_t i, n; uint32_t j, x; unsigned char *p; /* First pass: check for validity and get output length */ for( i = n = j = 0; i < slen; i++ ) { /* Skip s...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx testq %r8, %r8 je 0x33d33 xorl %ebx, %ebx leaq 0xbbf3(%rip), %r9 # 0x3f840 xorl %r11d, %r11d xorl %eax, %eax leaq 0x1(%rax), %r10 cmpq %r10, %r8 cmovaq %r8, %r10 movq %r10, %r15 subq %rax, %r15 leaq (%rcx,%rax), %r12 xorl %r14d, %r14d cmpb $0x20, (%r12,%r14) ...
/ARMmbed[P]mbed-crypto/library/base64.c
mnf::CartesianProduct::description(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const
std::string CartesianProduct::description(const std::string& prefix, bool firstCall) const { std::stringstream ss; if (firstCall) { ss << prefix << "/cartprod--------------------------" << std::endl; ss << this->description(prefix + "| ", false); ss << prefix ...
pushq %rbp movq %rsp, %rbp subq $0x2f0, %rsp # imm = 0x2F0 movq %rdi, -0x278(%rbp) movb %cl, %al movq %rdi, %rcx movq %rcx, -0x270(%rbp) movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq %rdx, -0x18(%rbp) andb $0x1, %al movb %al, -0x19(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x268(%rbp) leaq -0x1a8(%rbp), %...
/stanislas-brossette[P]manifolds/src/CartesianProduct.cpp
mnf::CartesianProduct::pseudoLog0_(Eigen::Ref<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::InnerStride<1>>, Eigen::Ref<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, 0, Eigen::InnerStride<1>> const&) const
void CartesianProduct::pseudoLog0_(RefVec out, const ConstRefVec& x) const { for (size_t i = 0; i < subManifolds_.size(); ++i) { subManifolds_[i]->pseudoLog0(getView<T>(out, i), getConstView<R>(x, i)); } }
pushq %rbp movq %rsp, %rbp subq $0x150, %rsp # imm = 0x150 movq %rsi, -0x108(%rbp) movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq %rdx, -0x18(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x100(%rbp) movq $0x0, -0x20(%rbp) movq -0x100(%rbp), %rdi movq -0x20(%rbp), %rax movq %rax, -0x110(%rbp) addq $0x58, %rdi c...
/stanislas-brossette[P]manifolds/src/CartesianProduct.cpp
mnf::ExpMapMatrix::diffPseudoLog0_(Eigen::Ref<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, 0, Eigen::InnerStride<1>> const&)
Eigen::Matrix<double, 3, 9> ExpMapMatrix::diffPseudoLog0_(const ConstRefVec& R) { Eigen::Matrix<double, 3, 9> J; J.setZero(); // Valid approximation of the log when v<<1 Eigen::Vector3d v((R(5) - R(7)) / 2, (R(6) - R(2)) / 2, (R(1) - R(3)) / 2); double trR = R(0) + R(4) + R(8); // Trace of R; double trRm1...
pushq %rbp movq %rsp, %rbp subq $0x3f0, %rsp # imm = 0x3F0 movq %rdi, -0x3e8(%rbp) movq %rdi, %rax movq %rax, -0x3f0(%rbp) movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) callq 0x186720 movq -0x3e8(%rbp), %rdi callq 0x182610 movq -0x10(%rbp), %rdi movl $0x5, %esi callq 0x182e00 movsd %xmm0, -0x3e0(%rbp) movq -0...
/stanislas-brossette[P]manifolds/src/ExpMapMatrix.cpp
mnf::ExpMapMatrix::applyInvTransport_(Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const&, Eigen::Ref<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, 0, Eigen::InnerStride<1>> const&, Eigen::Ref<Eigen...
void ExpMapMatrix::applyInvTransport_(RefMat out, const ConstRefMat& in, const ConstRefVec&, const ConstRefVec&) { // OutputType E; // exponential(E,v); // Eigen::Map<Eigen::MatrixXd, Eigen::Aligned> a = m.getMap(in.rows(), // InputDim_); // a.noalias() = in*(E.transpose(...
pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq %rdx, -0x18(%rbp) movq %rcx, -0x20(%rbp) movq -0x10(%rbp), %rsi callq 0x1841c0 addq $0x20, %rsp popq %rbp retq nopw (%rax,%rax)
/stanislas-brossette[P]manifolds/src/ExpMapMatrix.cpp
mnf::ExpMapQuaternion::isInM_(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, double)
bool ExpMapQuaternion::isInM_(const Eigen::VectorXd& val, double prec) { bool out(val.size() == 4); double norm = toConstQuat(val.data()).norm(); out = out && (fabs(norm - 1) < prec); return out; }
pushq %rbp movq %rsp, %rbp subq $0x70, %rsp movq %rdi, -0x8(%rbp) movsd %xmm0, -0x10(%rbp) movq -0x8(%rbp), %rdi callq 0x189270 subq $0x4, %rax sete -0x11(%rbp) movq -0x8(%rbp), %rdi callq 0x18ae20 movq %rax, %rsi leaq -0x40(%rbp), %rdi movq %rdi, -0x60(%rbp) callq 0x186a00 movq -0x60(%rbp), %rdi callq 0x1930b0 movsd %...
/stanislas-brossette[P]manifolds/src/ExpMapQuaternion.cpp
mnf::Point::Point(mnf::ConstSubPoint const&)
Point::Point(const ConstSubPoint& other) : PointMemory(other.value()), SubPoint(other.getManifold(), getMem()) { }
pushq %rbp movq %rsp, %rbp subq $0x90, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x78(%rbp) addq $0x8, %rax movq %rax, -0x70(%rbp) movq -0x10(%rbp), %rsi leaq -0x38(%rbp), %rdi movq %rdi, -0x68(%rbp) callq 0x188d90 movq -0x70(%rbp), %rdi movq -0x68(%rbp), %rsi callq 0x17fd10 jm...
/stanislas-brossette[P]manifolds/src/Point.cpp
Catch::BinaryExpr<C_A_T_C_H_T_E_S_T_12()::Test* const&, std::nullptr_t const&> const Catch::ExprLhs<C_A_T_C_H_T_E_S_T_12()::Test* const&>::operator==<std::nullptr_t>(std::nullptr_t const&)
auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const { return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs }; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movq %rdi, %r14 movq (%rsi), %r12 movq (%r12), %r13 leaq 0xdb5a(%rip), %rsi # 0x21b0f movq %rsp, %r15 movq %r15, %rdi callq 0x12110 testq %r13, %r13 movb $0x1, 0x8(%r14) sete 0x9(%r14) movups (%r15), %xmm0 leaq 0x16cc0(%rip), %...
/rezalas[P]riftshadow/tests/catch.hpp
fmt::v9::detail::format_decimal_result<char*> fmt::v9::detail::format_decimal<char, unsigned __int128>(char*, unsigned __int128, int)
FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size) -> format_decimal_result<Char*> { FMT_ASSERT(size >= count_digits(value), "invalid digit count"); out += size; Char* end = out; while (value >= 100) { // Integer division is slow so do it for a group of two digits instead // of for...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %ecx, %ebx movq %rdx, %r12 movq %rsi, %r14 movq %rdi, %r15 movq %rsi, %rdi movq %rdx, %rsi callq 0x14e7a cmpl %ebx, %eax jg 0x14e31 movslq %ebx, %rax leaq (%r15,%rax), %rbx addq %rax, %r15 addq $-0x2, %r15 pushq $0x64 popq %r13 leaq 0xc82...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
int fmt::v9::detail::count_digits_fallback<unsigned __int128>(unsigned __int128)
FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { int count = 1; for (;;) { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. if (n < ...
pushq %r15 pushq %r14 pushq %rbx pushq $0x4 popq %rbx pushq $0x63 popq %r14 movl $0x3e7, %r15d # imm = 0x3E7 cmpq $0xa, %rdi movq %rsi, %rax sbbq $0x0, %rax jb 0x14eda cmpq %rdi, %r14 movl $0x0, %eax sbbq %rsi, %rax jae 0x14edf cmpq %rdi, %r15 movl $0x0, %eax sbbq %rsi, %rax jae 0x14ee4 cmpq $0x2710, %rdi ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, unsigned __int128, 0>(fmt::v9::appender, unsigned __int128)
FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value); bool negative = is_negative(value); // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. if (negative) abs_value = ~abs_value + 1; int num_digits = count_digits(ab...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx movq %rsi, %rdi movq %rdx, %rsi callq 0x14e7a movl %eax, %ebp movslq %eax, %rsi movq %rbx, %rdi callq 0x1488c testq %rax, %rax je 0x14f2d movq %rax, %rdi movq %r15, %rsi movq %r14, %rdx movl %ebp, %ecx callq 0x14d7c j...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, bool, 0>(fmt::v9::appender, bool, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)
FMT_CONSTEXPR auto write(OutputIt out, T value, const basic_format_specs<Char>& specs = {}, locale_ref = {}) -> OutputIt { return specs.type != presentation_type::none && specs.type != presentation_type::string ? write(out, value ? 1 : 0,...
movq %rdx, %rcx movzbl 0x8(%rdx), %eax testb $-0x11, %al jne 0x14f7e leaq 0xc7d3(%rip), %rdx # 0x21733 leaq 0xc7d1(%rip), %rax # 0x21738 testb %sil, %sil cmovneq %rdx, %rax movzbl %sil, %edx xorq $0x5, %rdx movq %rax, %rsi jmp 0x14fa7 movzwl 0x9(%rcx), %eax shrl $0x2, %eax andl $0x1c, %eax leaq 0xc121(%rip), ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_int_noinline<char, fmt::v9::appender, unsigned int>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned int>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)
FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline( OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char>& specs, locale_ref loc) -> OutputIt { return write_int(out, arg, specs, loc); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rcx, %r8 movq %rdi, 0x40(%rsp) movzbl 0x8(%rdx), %ecx cmpq $0xf, %rcx ja 0x153e0 movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %rbx movq %rsi, %r14 shrq $0x20, %r14 leaq 0xc03e(%rip), %rax # 0x21040 movslq (%rax,%rcx,4), %rdx add...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::digit_grouping<char>::digit_grouping(fmt::v9::detail::locale_ref, bool)
explicit digit_grouping(locale_ref loc, bool localized = true) { if (localized) sep_ = thousands_sep<Char>(loc); else sep_.thousands_sep = Char(); }
pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, (%rdi) andq $0x0, 0x8(%rdi) movb $0x0, 0x10(%rdi) testl %edx, %edx je 0x154ba movq %rsp, %rdi callq 0x1557c movq %rsp, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x155c8 movq %r14, %rdi callq 0x12230 jmp 0x154be movb $0x0, 0x20(%rbx...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_int_localized<fmt::v9::appender, unsigned long, char>(fmt::v9::appender, unsigned long, unsigned int, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::digit_grouping<char> const&)
auto write_int_localized(OutputIt out, UInt value, unsigned prefix, const basic_format_specs<Char>& specs, const digit_grouping<Char>& grouping) -> OutputIt { static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, ""); int num_digits = count_digits(value); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %r8, %r15 movq %rcx, 0x8(%rsp) movl %edx, %ebp movq %rsi, %r12 movq %rdi, %r14 leaq 0x4(%rsp), %rax movl %edx, (%rax) movq %rsi, %rdi callq 0x14c68 movl %eax, %r13d movq %rsp, %rax movl %r13d, (%rax) leaq 0x30(%rsp), %rbx movq %rbx,...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::thousands_sep_result<char> fmt::v9::detail::thousands_sep_impl<char>(fmt::v9::detail::locale_ref)
FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> { auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()); auto grouping = facet.grouping(); auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); return {std::move(grouping), thousands_sep}; }
pushq %r15 pushq %r14 pushq %rbx subq $0x30, %rsp movq %rdi, %rbx leaq 0x28(%rsp), %rax movq %rsi, (%rax) leaq 0x8(%rsp), %r14 movq %r14, %rdi movq %rax, %rsi callq 0x156c2 movq %r14, %rdi callq 0x12250 movq %rax, %r14 leaq 0x8(%rsp), %rdi callq 0x122e0 movq (%r14), %rax leaq 0x8(%rsp), %r15 movq %r15, %rdi movq %r14, ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
unsigned long fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int_localized<fmt::v9::appender, unsigned long, char>(fmt::v9::appender, unsigned long, unsigned int, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::digit_grouping<char> con...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0xc7ba(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::digit_grouping<char>::next(fmt::v9::detail::digit_grouping<char>::next_state&) const
int next(next_state& state) const { if (!sep_.thousands_sep) return max_value<int>(); if (state.group == sep_.grouping.end()) return state.pos += sep_.grouping.back(); if (*state.group <= 0 || *state.group == max_value<char>()) return max_value<int>(); state.pos += *state.group++; return...
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF cmpb $0x0, 0x20(%rdi) je 0x1580a movq (%rdi), %rdx addq 0x8(%rdi), %rdx movq (%rsi), %rcx cmpq %rdx, %rcx je 0x157fb movb (%rcx), %dl addb $-0x7f, %dl cmpb $-0x7e, %dl jb 0x1580a leaq 0x1(%rcx), %rax movq %rax, (%rsi) jmp 0x15801 decq %rdx movq %rdx, %rcx movsbl (%rcx), %...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::fill<fmt::v9::appender, char>(fmt::v9::appender, unsigned long, fmt::v9::detail::fill_t<char> const&)
FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, const fill_t<Char>& fill) -> OutputIt { auto fill_size = fill.size(); if (fill_size == 1) return detail::fill_n(it, n, fill[0]); auto data = fill.data(); for (size_t i = 0; i < n; ++i) it = copy_str<Char>(data, ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movzbl 0x4(%rdx), %r12d cmpq $0x1, %r12 jne 0x15840 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x158bd addq %rbx, %r12 subq $0x1, %r14 jb 0x15859 movq %...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::digit_grouping<char>::apply<fmt::v9::appender, char>(fmt::v9::appender, fmt::v9::basic_string_view<char>) const
Out apply(Out out, basic_string_view<C> digits) const { auto num_digits = static_cast<int>(digits.size()); auto separators = basic_memory_buffer<int>(); separators.push_back(0); auto state = initial_state(); while (int i = next(state)) { if (i >= num_digits) break; separators.push_back(i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x818, %rsp # imm = 0x818 movq %rcx, %r14 movq %rdx, 0x8(%rsp) movq %rsi, %rbx movq %rdi, %r12 leaq 0x40(%rsp), %rax andq $0x0, -0x10(%rax) leaq 0x15280(%rip), %rcx # 0x2ab98 movq %rcx, -0x20(%rax) movq %rax, -0x18(%rax) movq $0x1f4,...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned int>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned int>, fmt::v9::basic_f...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0xc30d(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
char* fmt::v9::detail::format_uint<4u, char, unsigned int>(char*, unsigned int, int, bool)
FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, bool upper = false) -> Char* { buffer += num_digits; Char* end = buffer; do { const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; unsigned digit = static_cast<unsigned>(value & ((1 << ...
movslq %edx, %r8 leaq (%rdi,%r8), %rax leaq 0xba01(%rip), %r9 # 0x2177f leaq 0xba0b(%rip), %rdx # 0x21790 testl %ecx, %ecx cmovneq %r9, %rdx leaq (%rdi,%r8), %rcx decq %rcx movl %esi, %edi movl %esi, %r8d andl $0xf, %r8d movb (%rdx,%r8), %r8b movb %r8b, (%rcx) shrl $0x4, %edi decq %rcx cmpl $0xf, %esi movl %...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::format_uint<1u, char, fmt::v9::appender, unsigned int>(fmt::v9::appender, unsigned int, int, bool)
inline auto format_uint(It out, UInt value, int num_digits, bool upper = false) -> It { if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) { format_uint<BASE_BITS>(ptr, value, num_digits, upper); return out; } // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl %ecx, %r15d movl %edx, %ebp movl %esi, %r14d movq %rdi, %rbx movl %edx, %edi callq 0x156df movl %eax, %esi movq %rbx, %rdi callq 0x1488c movzbl %r15b, %ecx testq %rax, %rax je 0x15ef9 movq %rax, %rdi movl %r14d, %esi movl %ebp, %edx callq 0x15f2c jmp 0x1...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_escaped_cp<fmt::v9::appender, char>(fmt::v9::appender, fmt::v9::detail::find_escape_result<char> const&)
auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape) -> OutputIt { auto c = static_cast<Char>(escape.cp); switch (escape.cp) { case '\n': *out++ = static_cast<Char>('\\'); c = static_cast<Char>('n'); break; case '\r': *out++ = static_cast<Char>('\\'); c = static_ca...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movl 0x10(%rsi), %edx movb %dl, 0xb(%rsp) cmpl $0x9, %edx je 0x163ea cmpl $0x5c, %edx je 0x163a2 cmpl $0xd, %edx je 0x163b4 cmpl $0x22, %edx je 0x163a2 cmpl $0x27, %edx je 0x163a2 cmpl $0xa, %edx jne 0x163cb leaq 0xf(%rsp), %rsi mov...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::is_printable(unsigned int)
FMT_FUNC auto is_printable(uint32_t cp) -> bool { static constexpr singleton singletons0[] = { {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0...
cmpl $0xffff, %edi # imm = 0xFFFF ja 0x164bc movzwl %di, %edi leaq 0xbbe0(%rip), %rsi # 0x22080 leaq 0xbc39(%rip), %rcx # 0x220e0 leaq 0xbe62(%rip), %r8 # 0x22310 pushq $0x29 popq %rdx movl $0x135, %r9d # imm = 0x135 jmp 0x16572 cmpl $0x1ffff, %edi # imm = 0x1FFFF ja 0x164e...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
fmt::v9::appender fmt::v9::detail::write_codepoint<4ul, char, fmt::v9::appender>(fmt::v9::appender, char, unsigned int)
auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { *out++ = static_cast<Char>('\\'); *out++ = static_cast<Char>(prefix); Char buf[width]; fill_n(buf, width, static_cast<Char>('0')); format_uint<4>(buf, cp, width); return copy_str<Char>(buf, buf + width, out); }
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movl %edx, %ebp movl %esi, %r14d movq %rdi, %rbx leaq 0xb(%rsp), %rsi movb $0x5c, (%rsi) callq 0x149d2 leaq 0xa(%rsp), %rsi movb %r14b, (%rsi) movq %rbx, %rdi callq 0x149d2 leaq 0xc(%rsp), %r14 movl $0x30303030, (%r14) # imm = 0x30303030 pushq $0x4 popq %rdx movq %r...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, float, 0>(fmt::v9::appender, float)
FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { if (is_constant_evaluated()) return write(out, value, basic_format_specs<Char>()); if (const_check(!is_supported_floating_point(value))) return out; auto fspecs = float_specs(); if (detail::signbit(value)) { fspecs.sign = sign::minus; ...
pushq %rbx subq $0x30, %rsp andq $0x0, 0x8(%rsp) movq %rdi, %rbx movd %xmm0, %eax testl %eax, %eax jns 0x16820 movl $0x100, 0xc(%rsp) # imm = 0x100 pxor 0xa860(%rip), %xmm0 # 0x21080 movups 0xa879(%rip), %xmm1 # 0x210a0 movaps %xmm1, 0x10(%rsp) movd %xmm0, %eax andl $0x7fffffff, %eax # imm = 0x7FFFF...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::dragonbox::to_decimal<float>(float)
static uint64_t get_cached_power(int k) noexcept { FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, "k is out of range"); static constexpr const uint64_t pow10_significands[] = { 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movd %xmm0, %ebp movl %ebp, %r12d andl $0x7fffff, %r12d # imm = 0x7FFFFF shrl $0x17, %ebp andl $0xff, %ebp je 0x16957 addl $0xffffff6a, %ebp # imm = 0xFFFFFF6A testl %r12d, %r12d je 0x16acd orl $0x800000, %r12d # imm ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
fmt::v9::detail::dragonbox::cache_accessor<float>::get_cached_power(int)
static uint64_t get_cached_power(int k) noexcept { FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, "k is out of range"); static constexpr const uint64_t pow10_significands[] = { 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca...
addl $0x1f, %edi cmpl $0x4e, %edi jae 0x16cec movl %edi, %eax leaq 0xb919(%rip), %rcx # 0x22600 movq (%rcx,%rax,8), %rax retq pushq %rax leaq 0xaabd(%rip), %rdi # 0x217b1 leaq 0xab3d(%rip), %rdx # 0x21838 movl $0x12b, %esi # imm = 0x12B callq 0x149ab
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
bool fmt::v9::detail::dragonbox::check_divisibility_and_divide_by_pow10<1>(unsigned int&)
bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept { // The numbers below are chosen such that: // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, // 2. nm mod 2^k < m if and only if n is divisible by d, // where m is magic_number, k is shift_amount // and d is divisor. // // Item ...
movl (%rdi), %eax cmpl $0x65, %eax jae 0x16dd2 imull $0x199a, %eax, %ecx # imm = 0x199A movzwl %cx, %eax cmpl $0x199a, %eax # imm = 0x199A setb %al shrl $0x10, %ecx movl %ecx, (%rdi) retq pushq %rax leaq 0xa9d7(%rip), %rdi # 0x217b1 leaq 0xaa69(%rip), %rdx # 0x2184a movl $0x103, %esi ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detai...
FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const basic_format_specs<Char>& specs, float_specs fspecs, locale_ref loc) -> OutputIt { auto significand = f.significand; int significand_size = get_significand_size(f);...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xd8, %rsp movq %r8, %rbp movq %rcx, %r12 movq %rdx, 0x28(%rsp) movq %rdi, 0x18(%rsp) movq %rcx, 0x50(%rsp) movl (%rsi), %eax movl %eax, 0x40(%rsp) movl %eax, 0xc(%rsp) movq %rsi, 0x20(%rsp) movq %rsi, %rdi callq 0x172cb movl %eax, %r14d movl %eax,...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detai...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0xaaee(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
char* fmt::v9::detail::write_significand<char, unsigned int, 0>(char*, unsigned int, int, int, char)
inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* { if (!decimal_point) return format_decimal(out, significand, significand_size).end; out += significand_size + 1; Char* end = out; int floating_size ...
pushq %r14 pushq %rbx pushq %rax testb %r8b, %r8b je 0x17659 movslq %edx, %r9 leaq (%rdi,%r9), %rbx incq %rbx addq %r9, %rdi subl %ecx, %r9d pushq $0x2 popq %r10 movl %r9d, %eax cltd idivl %r10d movl %eax, %r10d pushq $0x64 popq %r11 leaq 0x9fbf(%rip), %r14 # 0x215ed testl %r10d, %r10d jle 0x1764e movl %esi, %eax ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_significand<char, fmt::v9::appender, unsigned int, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned int, int, int, fmt::v9::detail::digit_grouping<char> const&)
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt { if (!grouping.separator()) { out = write_significand<Char>(out, significand, significand_siz...
pushq %r15 pushq %r14 pushq %rbx subq $0x220, %rsp # imm = 0x220 movl %ecx, %ebx movq %rdi, %r15 cmpb $0x0, 0x20(%r8) je 0x1782a movq %r8, %r14 leaq 0x28(%rsp), %rax andq $0x0, -0x10(%rax) leaq 0x13380(%rip), %rcx # 0x2ab58 movq %rcx, -0x20(%rax) movq %rax, -0x18(%rax) movq $0x1f4, -0x8(%rax) # imm ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detai...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0xa68c(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_significand<fmt::v9::appender, char, unsigned int, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned int, int, int, char, fmt::v9::detail::digit_grouping<char> const&)
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping& grouping) -> OutputIt { if (!grouping.separator()) { ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x218, %rsp # imm = 0x218 movl %ecx, %ebp movq %rdi, %rbx cmpb $0x0, 0x20(%r9) je 0x17a0d movq %r9, %r14 leaq 0x20(%rsp), %rax andq $0x0, -0x10(%rax) leaq 0x131b9(%rip), %rcx # 0x2ab58 movq %rcx, -0x20(%rax) movq %rax, -0x18(%rax) movq $0x1f4, -0x8(%rax) ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detai...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0xa4bf(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, double, 0>(fmt::v9::appender, double)
FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { if (is_constant_evaluated()) return write(out, value, basic_format_specs<Char>()); if (const_check(!is_supported_floating_point(value))) return out; auto fspecs = float_specs(); if (detail::signbit(value)) { fspecs.sign = sign::minus; ...
pushq %rbx subq $0x30, %rsp andq $0x0, 0x8(%rsp) movq %rdi, %rbx movq %xmm0, %rax testq %rax, %rax jns 0x17b73 movl $0x100, 0xc(%rsp) # imm = 0x100 pxor 0x951d(%rip), %xmm0 # 0x21090 movups 0x9526(%rip), %xmm1 # 0x210a0 movaps %xmm1, 0x10(%rsp) movq %xmm0, %rax btrq $0x3f, %rax movabsq $0x7ff0000000000000...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::cache_accessor<double>::get_cached_power(int)
static uint128_fallback get_cached_power(int k) noexcept { FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k, "k is out of range"); static constexpr const uint128_fallback pow10_significands[] = { #if FMT_USE_FULL_CACHE_DRAGONBOX {0xff77b1fcbebcdc4f, 0x25e8e89c13b...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx leal 0x124(%rdi), %eax cmpl $0x26b, %eax # imm = 0x26B jae 0x180a7 movw $0x1b, %cx xorl %edx, %edx divw %cx imull $0x1b, %eax, %ecx movzwl %cx, %ebp addl $0xfffffedc, %ebp # imm = 0xFFFFFEDC movzwl %ax, %eax shll $0x4, %eax movl %edi, %r12d leaq 0x...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
fmt::v9::detail::dragonbox::cache_accessor<double>::compute_mul_parity(unsigned long, fmt::v9::detail::uint128_fallback const&, int)
static compute_mul_parity_result compute_mul_parity( carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul192_lower128(two_f, cache); return {((r.high() >> (64 - beta)) & 1) != 0, ((r.high() << beta)...
pushq %rax testl %edx, %edx jle 0x18154 movl %edx, %ecx cmpl $0x40, %edx jae 0x1816c movq %rdi, %rax mulq (%rsi) movq 0x8(%rsi), %rsi imulq %rdi, %rsi addq %rsi, %rdx movb $0x40, %sil subb %cl, %sil movzbl %sil, %edi xorl %esi, %esi btq %rdi, %rdx setb %sil shldq %cl, %rax, %rdx xorl %eax, %eax testq %rdx, %rdx sete %a...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h
fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::det...
FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const basic_format_specs<Char>& specs, float_specs fspecs, locale_ref loc) -> OutputIt { auto significand = f.significand; int significand_size = get_significand_size(f);...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xe8, %rsp movq %r8, %rbp movq %rcx, %r12 movq %rdx, 0x30(%rsp) movq %rdi, 0x20(%rsp) movq %rcx, 0x60(%rsp) movq (%rsi), %rax movq %rax, 0x58(%rsp) movq %rax, 0x40(%rsp) movq %rsi, 0x28(%rsp) movq %rsi, %rdi callq 0x1868d movl %eax, %r14d movl %eax...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::det...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0x978b(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
char* fmt::v9::detail::write_significand<char, unsigned long, 0>(char*, unsigned long, int, int, char)
inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* { if (!decimal_point) return format_decimal(out, significand, significand_size).end; out += significand_size + 1; Char* end = out; int floating_size ...
pushq %r14 pushq %rbx pushq %rax testb %r8b, %r8b je 0x18886 movslq %edx, %r9 leaq (%rdi,%r9), %rbx incq %rbx addq %r9, %rdi subl %ecx, %r9d pushq $0x2 popq %r10 movl %r9d, %eax cltd idivl %r10d movl %eax, %r10d leaq 0x8d98(%rip), %r11 # 0x215ed pushq $0x64 popq %r14 testl %r10d, %r10d jle 0x1887b movq %rsi, %rax ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::det...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0x9637(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_significand<char, fmt::v9::appender, unsigned long, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned long, int, int, fmt::v9::detail::digit_grouping<char> const&)
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt { if (!grouping.separator()) { out = write_significand<Char>(out, significand, significand_siz...
pushq %r15 pushq %r14 pushq %rbx subq $0x220, %rsp # imm = 0x220 movl %ecx, %ebx movq %rdi, %r15 cmpb $0x0, 0x20(%r8) je 0x18a59 movq %r8, %r14 leaq 0x28(%rsp), %rax andq $0x0, -0x10(%rax) leaq 0x12151(%rip), %rcx # 0x2ab58 movq %rcx, -0x20(%rax) movq %rax, -0x18(%rax) movq $0x1f4, -0x8(%rax) # imm ...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::det...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0x945d(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::det...
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); siz...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %r8, %r15 movq %rcx, %r13 movq %rsi, %rbx movq %rdi, %r12 movl (%rsi), %edi callq 0x156df movl %eax, %eax xorl %r14d, %r14d subq %r13, %rax cmovaeq %rax, %r14 movzwl 0x9(%rbx), %eax andl $0xf, %eax leaq 0x9290(%rip), %rcx # 0x21f30 movb (%rax,%rcx), %cl m...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::bigint::square()
FMT_CONSTEXPR20 void square() { int num_bigits = static_cast<int>(bigits_.size()); int num_result_bigits = 2 * num_bigits; basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_)); bigits_.resize(to_unsigned(num_result_bigits)); auto sum = uint128_t(); for (int bigit_index = 0; bigit_in...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xb8, %rsp movq %rdi, %rbx movq 0x10(%rdi), %r14 leal (%r14,%r14), %ebp leaq 0x10(%rsp), %rdi movq %rbx, %rsi callq 0x1a322 movl %ebp, 0x4(%rsp) movl %ebp, %edi callq 0x156df movl %eax, %esi movq %rbx, %rdi callq 0x1a130 xorl %r15d, %r15d testl %r1...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::bigint::remove_leading_zeros()
FMT_CONSTEXPR20 void remove_leading_zeros() { int num_bigits = static_cast<int>(bigits_.size()) - 1; while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits; bigits_.resize(to_unsigned(num_bigits + 1)); }
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movl 0x10(%rdi), %ebp movl %ebp, %r14d cmpl $0x2, %ebp jl 0x1a371 leal -0x1(%r14), %ebp movl %ebp, %edi callq 0x156df movq 0x8(%rbx), %rcx movl %eax, %eax cmpl $0x0, (%rcx,%rax,4) je 0x1a352 movl %r14d, %edi callq 0x156df movl %eax, %esi movq %rbx, %rdi popq %rbx popq %r...
/rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h