name string | code string | asm string | file string |
|---|---|---|---|
mbedtls_rsa_deduce_private_exponent | int mbedtls_rsa_deduce_private_exponent( mbedtls_mpi const *P,
mbedtls_mpi const *Q,
mbedtls_mpi const *E,
mbedtls_mpi *D )
{
int ret = 0;
mbedtls_mpi K, L;
if( D == NULL || mbedtls_mp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC
testq %rcx, %rcx
je 0x1a76e
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
xorl %esi, %esi
callq 0xbb68
testl %eax, %eax
je 0x1a77f
movl %ebp, %eax
addq $0x... | /project-everest[P]mbedtls/library/rsa_internal.c |
mbedtls_md_info_from_string | const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name )
{
if( NULL == md_name )
return( NULL );
/* Get the appropriate digest information */
#if defined(MBEDTLS_MD2_C)
if( !strcmp( "MD2", md_name ) )
return mbedtls_md_info_from_type( MBEDTLS_MD_MD2 );
#endif
#if defined(... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2309c
movq %rdi, %rbx
leaq 0x15c55(%rip), %rdi # 0x38c48
movq %rbx, %rsi
callq 0xa100
testl %eax, %eax
je 0x230a1
leaq 0x15766(%rip), %rdi # 0x38770
movq %rbx, %rsi
callq 0xa100
testl %eax, %eax
je 0x230aa
leaq 0x15d4f(%rip), %rdi # 0x38d70
movq %rbx, %... | /project-everest[P]mbedtls/library/md.c |
mbedtls_sha256_starts | int mbedtls_sha256_starts_ret( mbedtls_sha256_context *ctx, int is224 )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
if( is224 == 0 )
{
/* SHA-256 */
ctx->state[0] = 0x6A09E667;
ctx->state[1] = 0xBB67AE85;
ctx->state[2] = 0x3C6EF372;
ctx->state[3] = 0xA54FF53A;
... | movq $0x0, (%rdi)
testl %esi, %esi
je 0x271c4
movaps 0x12797(%rip), %xmm0 # 0x39950
jne 0x271cd
movaps 0x1279e(%rip), %xmm1 # 0x39960
jmp 0x271d4
movaps 0x12775(%rip), %xmm0 # 0x39940
je 0x271bb
movaps 0x1279c(%rip), %xmm1 # 0x39970
movups %xmm0, 0x8(%rdi)
movups %xmm1, 0x18(%rdi)
movl %esi, 0x68(%rdi)
retq... | /project-everest[P]mbedtls/library/sha256.c |
mbedtls_sha256_update_ret | int mbedtls_sha256_update_ret( mbedtls_sha256_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret;
size_t fill;
uint32_t left;
if( ilen == 0 )
return( 0 );
left = ctx->total[0] & 0x3F;
fill = 64 - left;
ct... | testq %rdx, %rdx
je 0x27cb9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x27c34
incl 0x4(%r14)
testl %eax, %eax
je 0x27c72
movl $0x40, %r15d
subq %rax, %r15
movq %rdx, %r13... | /project-everest[P]mbedtls/library/sha256.c |
mbedtls_sha256_ret | int mbedtls_sha256_ret( const unsigned char *input,
size_t ilen,
unsigned char output[32],
int is224 )
{
int ret;
mbedtls_sha256_context ctx;
mbedtls_sha256_init( &ctx );
if( ( ret = mbedtls_sha256_starts_ret( &ctx, is224 ) ) != 0... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x60(%rsp)
testl %ecx, %ecx
je 0x27e91
movaps 0x11aca(%ri... | /project-everest[P]mbedtls/library/sha256.c |
mbedtls_aes_crypt_cbc | int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[16];
if( length % 16 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl $0xffffffde, %eax # imm = 0xFFFFFFDE
testb $0xf, %r12b
jne 0x29fc7
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r13
testl %esi, %esi
je 0x29f80
testq %r12, %r12
je 0x29fc5
xorl %eax... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb8 | int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
unsigned char c;
unsigned char ov[17];
... | testq %rdx, %rdx
je 0x2a166
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbp
xorl %r14d, %r14d
movq %rdx, 0x20(%rsp)
movl %esi, 0xc(%rsp)
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x18(%rsp)
mov... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_aesni_crypt_ecb | int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
"pxor... | movl (%rdi), %eax
movq 0x8(%rdi), %rdi
movdqu (%rdx), %xmm0
movdqu (%rdi), %xmm1
pxor %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
testl %esi, %esi
je 0x2a95d
movdqu (%rdi), %xmm1
aesenc %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
jne 0x2a940
movdqu (%rdi), %xmm1
aesenclast %xmm1, %xmm0
jmp 0x2a978
movdqu (%rdi), %x... | /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_gcm_mult | void mbedtls_aesni_gcm_mult( unsigned char c[16],
const unsigned char a[16],
const unsigned char b[16] )
{
unsigned char aa[16], bb[16], cc[16];
size_t i;
/* The inputs are in big-endian order, so byte-reverse them */
for( i = 0; i < 16; i++ )
{
aa[... | movdqu (%rsi), %xmm0
pxor %xmm6, %xmm6
movdqa %xmm0, %xmm1
punpcklbw %xmm6, %xmm1 # xmm1 = xmm1[0],xmm6[0],xmm1[1],xmm6[1],xmm1[2],xmm6[2],xmm1[3],xmm6[3],xmm1[4],xmm6[4],xmm1[5],xmm6[5],xmm1[6],xmm6[6],xmm1[7],xmm6[7]
pshufd $0x4e, %xmm1, %xmm1 # xmm1 = xmm1[2,3,0,1]
pshuflw $0x1b, %xmm1, %xmm1 # xmm1 = xmm... | /project-everest[P]mbedtls/library/aesni.c |
mbedtls_aesni_inverse_key | void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%x... | shll $0x4, %edx
movslq %edx, %rax
addq %rsi, %rax
addq $-0x10, %rax
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
cmpq %rsi, %rax
jbe 0x2ab6d
movdqu (%rax), %xmm0
aesimc %xmm0, %xmm0
movdqu %xmm0, (%rdi)
addq $-0x10, %rax
jmp 0x2ab51
movups (%rax), %xmm0
movups %xmm0, (%rdi)
retq
| /project-everest[P]mbedtls/library/aesni.c |
mbedtls_arc4_setup | void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
unsigned int keylen )
{
int i, j, a;
unsigned int k;
unsigned char *m;
ctx->x = 0;
ctx->y = 0;
m = ctx->m;
for( i = 0; i < 256; i++ )
m[i] = (unsigned char) i;
j = k = 0;
for( i... | movq $0x0, (%rdi)
movdqa 0xf50e(%rip), %xmm0 # 0x3a310
xorl %eax, %eax
movdqa 0xf934(%rip), %xmm1 # 0x3a740
movdqu %xmm0, 0x8(%rdi,%rax)
addq $0x10, %rax
paddb %xmm1, %xmm0
cmpq $0x100, %rax # imm = 0x100
jne 0x2ae0c
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl %edx... | /project-everest[P]mbedtls/library/arc4.c |
mbedtls_asn1_write_raw_buffer | int mbedtls_asn1_write_raw_buffer( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
size_t len = 0;
if( *p < start || (size_t)( *p - start ) < size )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = size;
(*p) -= len;
memcpy( *p, ... | pushq %rbx
movq %rcx, %rbx
movq %rdi, %rcx
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %sil
cmpq %rbx, %rax
setb %al
orb %sil, %al
movl $0xffffff94, %eax # imm = 0xFFFFFF94
jne 0x2b184
subq %rbx, %rdi
movq %rdi, (%rcx)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xa120
movl %ebx, %eax
popq %rbx
retq
| /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_null | int mbedtls_asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
{
if( len < 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
return( 1 );
}
if( len <= 0xFF )
{
if( *p - start < 2 )
... | movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
movl $0xffffff94, %eax # imm = 0xFFFFFF94
testq %rdx, %rdx
jle 0x2b276
leaq -0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb $0x0, -0x1(%rcx)
movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
testq %rdx, %rdx
jle 0x2b276
leaq -0x1(%rcx), %rax
movq %rax, (%rdi)
movb $0x5, -... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_oid | int mbedtls_asn1_write_oid( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) oid, oid_len ) );
MBEDTLS_A... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %rbx, %rax
setb %al
orb %cl, %al
movl $0xffffff94, %ebp # imm = 0xFFFFFF94
jne 0x2b2f4
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx,... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_algorithm_identifier | int mbedtls_asn1_write_algorithm_identifier( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len,
size_t par_len )
{
int ret;
size_t len = 0;
if( par_len == 0 )
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_wri... | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %r8, %r8
je 0x2b35a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b277
testl %eax, %eax
js 0x2b3a1
movl %eax, %eax
addq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2afbc
testl %eax, %eax
js 0x2b3a1
movq (%rbx), %rcx
... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_bool | int mbedtls_asn1_write_bool( unsigned char **p, unsigned char *start, int boolean )
{
int ret;
size_t len = 0;
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (boolean) ? 255 : 0;
len++;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
... | movq (%rdi), %rcx
movq %rcx, %r8
subq %rsi, %r8
movl $0xffffff94, %eax # imm = 0xFFFFFF94
testq %r8, %r8
jle 0x2b404
xorl %r8d, %r8d
negl %edx
sbbl %r8d, %r8d
leaq -0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb %r8b, -0x1(%rcx)
movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
testq %rdx, %rdx
jle 0x2b404
leaq -0x1(%rcx... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_int | int mbedtls_asn1_write_int( unsigned char **p, unsigned char *start, int val )
{
int ret;
size_t len = 0;
// TODO negative values and values larger than 128
// DER format assumes 2s complement for numbers, so the leftmost bit
// should be 0 for positive numbers and 1 for negative numbers.
//
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
movl $0xffffff94, %ebx # imm = 0xFFFFFF94
testq %rcx, %rcx
jle 0x2b493
movq %rsi, %r15
movq %rdi, %r14
leaq -0x1(%rax), %rcx
movq %rcx, (%rdi)
movb %dl, -0x1(%rax)
movl $0x1, %r12d
testl %edx, %edx
jle 0x2b45e... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_store_named_data | mbedtls_asn1_named_data *mbedtls_asn1_store_named_data( mbedtls_asn1_named_data **head,
const char *oid, size_t oid_len,
const unsigned char *val,
size_t val_len )
{
mbedtls_asn1_named_data *cur;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x1c8fb
testq %rax, %rax
je 0x2b754
movq %rax, %rbx
cmpq %r14, 0x20(%rax)
jae 0x2b7c8
movq %r15, %r12
movl $0x1, %edi
movq %r14, %rsi
callq ... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_cipher_finish | int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*olen = 0;
if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
MBEDT... | pushq %r15
pushq %r14
pushq %rbx
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2c3a0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rbx, %rbx
sete %sil
orb %dl, %sil
jne 0x2c3a0
movq $0x0, (%rbx)
movl 0x4(%rcx), %edx
decl %edx
cmpl $0x6, %edx
j... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_crypt | int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen )
{
int ret;
size_t finish_olen;
if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2c76c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %dil
orb %dl, %dil
jne 0x2c75e
movl $0xffff9f80, %eax... | /project-everest[P]mbedtls/library/cipher.c |
blowfish_ctx_alloc | static void * blowfish_ctx_alloc( void )
{
mbedtls_blowfish_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_blowfish_init( ctx );
return( ctx );
} | pushq %rbx
movl $0x1, %edi
movl $0x1048, %esi # imm = 0x1048
callq 0xa0f0
movq %rax, %rbx
testq %rax, %rax
je 0x2ca09
movq %rbx, %rdi
callq 0x2fb48
movq %rbx, %rax
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher_wrap.c |
des3_ctx_alloc | static void * des3_ctx_alloc( void )
{
mbedtls_des3_context *des3;
des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
if( des3 == NULL )
return( NULL );
mbedtls_des3_init( des3 );
return( des3 );
} | pushq %rbx
movl $0x1, %edi
movl $0x180, %esi # imm = 0x180
callq 0xa0f0
movq %rax, %rbx
testq %rax, %rax
je 0x2cb1e
movq %rbx, %rdi
callq 0x2cb7a
movq %rbx, %rax
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher_wrap.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 0x2cc0b
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... | /project-everest[P]mbedtls/library/des.c |
mbedtls_des_crypt_cbc | int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl $0xffffffce, %eax # imm = 0xFFFFFFCE
testb $0x7, %r12b
jne 0x2d5a9
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
cmpl $0x1, %esi
jne 0x2d56e
testq %r12, %r12
je 0x2d5a7
xorl %eax, %eax
movb (%r15,%rax... | /project-everest[P]mbedtls/library/des.c |
mbedtls_gcm_setkey | int mbedtls_gcm_setkey( mbedtls_gcm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %edi
movl %ecx, %esi
movl $0x1, %edx
callq 0x2bd3f
movq %rax, %r15
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
testq %r15, %r15
je 0x2e181
cmpl $0x10, 0x20(%r15)
jne 0x2e181
movq %rbx, %rdi
callq ... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_update | int mbedtls_gcm_update( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *input,
unsigned char *output )
{
int ret;
unsigned char ectr[16];
size_t i;
const unsigned char *p;
unsigned char *out_p = output;
size_t use_len, olen = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq $0x0, 0x8(%rsp)
movq %rcx, %rax
subq %rdx, %rax
seta %cl
cmpq %rsi, %rax
setb %dl
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
testb %dl, %cl
jne 0x2e5f5
movq %rsi, %r15
movq %rdi, %r12
movq 0x158(... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_gcm_crypt_and_tag | int mbedtls_gcm_crypt_and_tag( mbedtls_gcm_context *ctx,
int mode,
size_t length,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %rdx, %r12
movq %rdi, %rbx
movq 0x60(%rsp), %r15
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
movq 0x40(%rsp), %r9
movq %rcx, %rdx
movq %r8, %rcx
movq %rax, %r8
callq 0x2e18c
testl %eax, %eax
jne 0x2e7f... | /project-everest[P]mbedtls/library/gcm.c |
mbedtls_blowfish_crypt_cfb64 | int mbedtls_blowfish_crypt_cfb64( mbedtls_blowfish_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[MBEDTLS_BLOWFISH_BLOCKSIZE],
const unsigned char *input,
un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq 0x50(%rsp), %rbx
movq %rcx, 0x10(%rsp)
movq (%rcx), %rbp
testl %esi, %esi
je 0x2ff29
testq %r12, %r12
je 0x2ff6a
xorl %r13d, %r13d
testq %rbp, %rbp
jne 0x2ff0a
movq ... | /project-everest[P]mbedtls/library/blowfish.c |
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];
RK = ctx->rk;
memset( t, 0, 64 )... | 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 ... | /project-everest[P]mbedtls/library/camellia.c |
mbedtls_camellia_setkey_dec | int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int idx, ret;
size_t i;
mbedtls_camellia_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_camellia_init( &cty );
/* Also checks keybits */
if( ( r... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl $0x114, %edx # imm = 0x114
movq %r15, %rdi
xorl %esi, %esi
callq 0xa0d0
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3003f
testl %eax, %e... | /project-everest[P]mbedtls/library/camellia.c |
mbedtls_camellia_crypt_cbc | int mbedtls_camellia_crypt_cbc( mbedtls_camellia_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[16];
if( length %... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movl $0xffffffda, %eax # imm = 0xFFFFFFDA
testb $0xf, %r12b
jne 0x30da9
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
testl %esi, %esi
je 0x30d64
testq %r12, %r12
je 0x30da7
xorl %eax, %eax
movb (%r15,%rax), %c... | /project-everest[P]mbedtls/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, 0x8(%rsp)
movq (%rdx), %rbx
testq %rsi, %rsi
je 0x30ef0
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq 0x50(%rsp), %rbp
testq %rbx, %rbx
jne 0x30ed3
movq 0x10(%rsp), %rdi
movq %r12, %r... | /project-everest[P]mbedtls/library/camellia.c |
mbedtls_ccm_setkey | int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %edi
movl %ecx, %esi
movl $0x1, %edx
callq 0x2bd3f
movq %rax, %r12
movl $0xfffffff3, %eax # imm = 0xFFFFFFF3
testq %r12, %r12
je 0x314b1
cmpl $0x10, 0x20(%r12)
jne 0x314b1
movq %r15, %rdi
callq 0x2bd9... | /project-everest[P]mbedtls/library/ccm.c |
mbedtls_ccm_auth_decrypt | int mbedtls_ccm_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 *tag, si... | 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 0x3152b
addq $... | /project-everest[P]mbedtls/library/ccm.c |
buffer_skip_whitespace | static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL))
{
return NULL;
}
while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
{
buffer->offset++;
}
if (buffer->offset == buffer->le... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b49
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2b56
movq $0x0, -0x8(%rbp)
jmp 0x2be0
jmp 0x2b58
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x2b9b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x0, %rcx
movq -0x1... | /FSMaxB[P]cJSON/cJSON.c |
print_number | static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)
{
unsigned char *output_pointer = NULL;
double d = item->valuedouble;
int length = 0;
size_t i = 0;
unsigned char number_buffer[26]; /* temporary buffer to print the number into */
unsigned char decimal_p... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x48(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movq $0x0, -0x70(%rbp)
callq 0x6560
movb %al, -0x71(%rbp)
cmpq $0x0, -... | /FSMaxB[P]cJSON/cJSON.c |
load_area(_IO_FILE*) | void load_area(FILE *fp)
{
AREA_DATA *pArea;
pArea = new AREA_DATA;
/*
pArea->reset_first = nullptr;
pArea->reset_last = nullptr;
*/
pArea->file_name = fread_string(fp);
pArea->prev = nullptr;
zero_vector(pArea->area_flags);
SET_BIT(pArea->area_flags, AREA_LOADING); /* OLC */
pArea->vnum = top_area; ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x170, %edi # imm = 0x170
callq 0x2b170
movq %rax, %rbx
movq %r14, %rdi
callq 0x2c2af
movq %rax, 0x38(%rbx)
xorl %r13d, %r13d
movq %r13, 0x8(%rbx)
leaq 0x60(%rbx), %r15
movq %r15, %rdi
callq 0x2b2e0
orb $0x20, 0x60(%rbx)
movl 0x4fca... | /rezalas[P]riftshadow/tests/../code/db.c |
sort_areas() | void sort_areas(void)
{
AREA_DATA *placeholder;
AREA_DATA *pArea;
bool sorted= false;
bool first= false;
int vnum = 0;
while (!sorted)
{
sorted = true;
for (pArea = area_first; pArea; pArea = pArea->next)
{
first= false;
if (!pArea->next)
break;
if (pArea == area_first)
first = true;
... | movb $0x1, %dl
movq 0x3385d(%rip), %rax # 0x5fef8
movq %rax, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x2c6e8
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x2c6e8
movzwl 0x58(%rcx), %edi
cmpw 0x58(%rsi), %di
jle 0x2c69e
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x2c6c4
movq %rcx, 0x8(%rdx)
movq 0x8(%rcx), %rdi
cmpq (%rax), ... | /rezalas[P]riftshadow/tests/../code/db.c |
str_cmp(char const*, char const*) | bool str_cmp(const char *astr, const char *bstr)
{
if (astr == nullptr)
{
// RS.Logger.Warn("Str_cmp: null astr, bstr: {} ({}:{} dev=pimp)",gLastFile, gLastLine, bstr);
return true;
}
if (bstr == nullptr)
{
// RS.Logger.Warn("Str_cmp: null bstr, astr: {}", astr);
return true;
}
for (; *astr || *bstr; a... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movb $0x1, %al
jne 0x2cbb8
xorl %ecx, %ecx
movsbl (%rdi,%rcx), %r8d
testl %r8d, %r8d
je 0x2cb8d
leal -0x41(%r8), %r9d
leal 0x20(%r8), %edx
cmpb $0x1a, %r9b
cmovael %r8d, %edx
movb (%rsi,%rcx), %r8b
jmp 0x2cb98
movb (%rsi,%rcx), %r8b
xorl %edx, %edx
testb ... | /rezalas[P]riftshadow/tests/../code/db.c |
assign_area_vnum(int) | void assign_area_vnum(int vnum)
{
if (area_last->min_vnum == 0 || area_last->max_vnum == 0)
area_last->min_vnum = area_last->max_vnum = vnum;
if (vnum != URANGE(area_last->min_vnum, vnum, area_last->max_vnum))
{
if (vnum < area_last->min_vnum)
area_last->min_vnum = vnum;
else
area_last->max_vnum = vnum;... | movq 0x407e0(%rip), %rax # 0x6d3a0
movzwl 0x58(%rax), %edx
testw %dx, %dx
je 0x2cbd2
movzwl 0x5a(%rax), %ecx
testw %cx, %cx
jne 0x2cbde
movw %di, 0x5a(%rax)
movw %di, 0x58(%rax)
movl %edi, %ecx
movl %edi, %edx
movswl %dx, %edx
cmpl %edi, %edx
jle 0x2cbea
movw %di, 0x58(%rax)
retq
movswl %cx, %ecx
cmpl %edi, %ecx
jg... | /rezalas[P]riftshadow/tests/../code/db.c |
get_mob_index(int) | MOB_INDEX_DATA *get_mob_index(int vnum)
{
MOB_INDEX_DATA *pMobIndex;
for (pMobIndex = mob_index_hash[vnum % MAX_KEY_HASH]; pMobIndex != nullptr; pMobIndex = pMobIndex->next)
{
if (pMobIndex->vnum == vnum)
return pMobIndex;
}
if (fBootDb)
{
RS.Logger.Error("Get_mob_index: funky vnum {}.", vnum);
exit(1)... | pushq %rax
movl %edi, 0x4(%rsp)
leal 0x3ff(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
movl %edi, %ecx
subl %eax, %ecx
movslq %ecx, %rax
leaq 0x38349(%rip), %rcx # 0x653a0
leaq (%rcx,%rax,8), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2d06d
movswl 0x48(%rax), %e... | /rezalas[P]riftshadow/tests/../code/db.c |
crappyold(int) | void *crappyold(int sMem)
{
/*
static char *pMemPerm;
static int iMemPerm;
void *pMem;
while (sMem % sizeof(long) != 0)
{
sMem++;
}
if (sMem > MAX_PERM_BLOCK)
{
RS.Logger.Error("Alloc_perm: {} too large.", sMem);
exit(1);
}
if (pMemPerm == nullptr || iMemPerm + sMem > MAX_PERM_BLOCK)
{
iMemPerm =... | xorl %eax, %eax
retq
| /rezalas[P]riftshadow/tests/../code/db.c |
str_suffix(char const*, char const*) | bool str_suffix(const char *astr, const char *bstr)
{
int sstr1 = strlen(astr);
int sstr2 = strlen(bstr);
if (sstr1 <= sstr2 && !str_cmp(astr, bstr + sstr2 - sstr1))
return false;
else
return true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2b380
movq %rax, %r15
movq %rbx, %rdi
callq 0x2b380
cmpl %eax, %r15d
jg 0x3021c
cltq
addq %rax, %rbx
movslq %r15d, %rax
subq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cb59
testb %al, %al
je 0x30220
movb $0x1, %al
jmp 0x30222
xorl %eax, %... | /rezalas[P]riftshadow/tests/../code/db.c |
append_file(char_data*, char*, char*) | void append_file(CHAR_DATA *ch, char *file, char *str)
{
FILE *fp;
char buf[MSL];
if (is_npc(ch) || str[0] == '\0')
return;
fclose(fpReserve);
fp = fopen(file, "a");
if (fp == nullptr)
{
RS.Logger.Warn("Append_file: fopen {}: {}", file, std::strerror(errno));
send_to_char("Could not open the file!\n\r"... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1210, %rsp # imm = 0x1210
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
callq 0x2b0f0
testb %al, %al
jne 0x303a0
cmpb $0x0, (%r14)
je 0x303a0
movq 0x2fcd9(%rip), %r13 # 0x5ff98
movq (%r13), %rdi
callq 0x2b3e0
leaq 0x1f64... | /rezalas[P]riftshadow/tests/../code/db.c |
spdlog::pattern_formatter::clone() const | SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const {
custom_flags cloned_custom_formatters;
for (auto &it : custom_handlers_) {
cloned_custom_formatters[it.first] = it.second->clone();
}
auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0xb8(%rsi), %r13
testq %... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::pattern_formatter::~pattern_formatter() | class SPDLOG_API pattern_formatter final : public formatter {
public:
using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>;
explicit pattern_formatter(std::string pattern,
pattern_time_type time_type = pattern_time_type::local,
... | pushq %rbx
movq %rdi, %rbx
addq $0xa8, %rdi
callq 0x34958
leaq 0x90(%rbx), %rdi
callq 0x42162
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x347da
movq (%rax), %rsi
incq %rsi
callq 0x2b130
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x347f3
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x2b13... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter.h |
Catch::BinaryExpr<int const&, int const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rax
movl (%rax), %esi
leaq 0x28(%rsp), %rdi
callq 0x2b710
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rax
movl (%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2b710
leaq 0x28(%rsp), %rsi
leaq 0x8(%... | /rezalas[P]riftshadow/tests/catch.hpp |
fmt::v9::detail::assert_fail(char const*, int, char const*) | FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
// Use unchecked std::fprintf to avoid triggering another assertion when
// writing to stderr fails
std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
// Chosen instead of std::abort to satisfy Clang in CUDA mode... | pushq %rax
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rdx
movq 0x2a99f(%rip), %rax # 0x5ff48
movq (%rax), %rdi
leaq 0x1b2a0(%rip), %rsi # 0x50853
xorl %eax, %eax
callq 0x2b1f0
callq 0x2b990
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, unsigned int, 0>(fmt::v9::appender, unsigned int) | FMT_INLINE auto do_count_digits(uint32_t n) -> int {
// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
# define FMT_INC(T) (((sizeof(# T) - 1ull) << 32) - T)
static constexpr uint64_t table[] = {
FMT_INC(0), FMT_... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %eax
orl $0x1, %eax
bsrl %eax, %ecx
leaq 0x1bac1(%rip), %rdx # 0x51140
movl %esi, %eax
addq (%rdx,%rcx,8), %rax
movq %rdi, %rbx
movq %rax, %rdx
shrq $0x20, %rdx
sarq $0x20, %rax
movq 0x10(%rdi), %rcx
addq %rcx, %rax
cmpq %rax, 0x18(%rdi)
jb 0x356b7
movq %rax, 0x10(%... | /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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpq $0xa, %rdi
movq %rsi, %rax
sbbq $0x0, %rax
jb 0x35b5f
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %ebx
movl $0x63, %r12d
movl $0x3e7, %r13d # imm = 0x3E7
movl $0x1869f, %ebp # imm = 0x1869F
cmpq %r15, %r1... | /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 0x36738
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36762
testq %r14, %r14
je 0x36753
addq %rbx, %r12
movq ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::basic_memory_buffer<int, 500ul, std::allocator<int>>::grow(unsigned long) | FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > ne... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
addq $0x7f0, %rdi # imm = 0x7F0
movq 0x18(%r14), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jae 0x369be
movq %rsi, %r15
jmp 0x369d8
movq %r15, %rax
shrq $0x3d, %rax
je 0x369d8
movabsq $0x1fffffffffffffff, %r15 # imm = ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_char<char, fmt::v9::appender>(fmt::v9::appender, char, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::basic_format_specs<char> ... | 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
movslq (%rsi), %rax
testq %rax, %rax
js 0x371d6
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x180aa(%rip), %rcx # 0x4f1e9
movb (%rax,%rcx), %cl
movq %r14, %r13
s... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_codepoint<2ul, 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
movq 0x10(%rdi), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rdi)
jae 0x376de
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x5c... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_codepoint<8ul, 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
movq 0x10(%rdi), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rdi)
jae 0x3783d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x5c... | /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
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movd %xmm0, %eax
testl %eax, %eax
jns 0x379a0
movl $0x100, 0xc(%rsp) # imm = 0x100
pxor 0x178f0(%rip), %xmm0 # 0x4f290
movups 0x17909(%rip), %xmm1 # 0x4f2b0
movaps %xmm1, 0x10(%rsp)
movd %xmm0, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFF... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_nonfinite<char, fmt::v9::appender>(fmt::v9::appender, bool, fmt::v9::basic_format_specs<char>, fmt::v9::detail::float_specs const&) | FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
basic_format_specs<Char> specs,
const float_specs& fspecs) -> OutputIt {
auto str =
isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
constexpr size_t... | subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x4(%r8), %eax
movabsq $-0xffffff01000000, %rdx # imm = 0xFF000000FF000000
andq %rcx, %rdx
movabsq $0x100000030000000, %rcx # imm = 0x100000030000000
cmpq %rcx, %rdx
jne 0x37a43
movb $0x20, 0x13(%rsp)
btl $0x10, %eax
leaq 0x18fa4(%rip), %rcx # 0x509f2... | /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 $0x18, %rsp
movd %xmm0, %esi
movl %esi, %r13d
andl $0x7fffff, %r13d # imm = 0x7FFFFF
movl %esi, %eax
shrl $0x17, %eax
andl $0xff, %eax
je 0x37add
addl $0xffffff6a, %eax # imm = 0xFFFFFF6A
testl %r13d, %r13d
je 0x37c56
orl $0x800000, %r1... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_nonfinite<char, fmt::v9::appender>(fmt::v9::appender, bool, fmt::v9::basic_format_specs<char>, fmt::v9::detail::float_specs const&)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender,... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0x37e66
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x1742c(%rip), %rcx # 0x4f1e9
movb (%rax,%rcx),... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::dragonbox::cache_accessor<float>::compute_mul_parity(unsigned int, unsigned long 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 = umul96_lower64(two_f, cache);
return {((r >> (64 - beta)) & 1) != 0,
static_cast<uint32_t>(r >> (... | pushq %rax
testl %edx, %edx
jle 0x37eb6
cmpl $0x40, %edx
jae 0x37ece
movl %edi, %edi
imulq (%rsi), %rdi
movb $0x40, %al
subb %dl, %al
movzbl %al, %ecx
xorl %eax, %eax
btq %rcx, %rdi
setb %al
addl $0x20, %edx
negl %edx
movl %edx, %ecx
shrq %cl, %rdi
xorl %ecx, %ecx
testl %edi, %edi
sete %cl
shll $0x8, %ecx
orl %ecx, %ea... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format-inl.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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x38616
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x16c26(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x388a2
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x1699a(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /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 %r12
pushq %rbx
subq $0x230, %rsp # imm = 0x230
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0x38c61
movq %r9, %r14
leaq 0x38(%rsp), %r12
movq $0x0, -0x10(%r12)
leaq 0x2574d(%rip), %rax # 0x5e340
movq %rax, -0x20(%r12)
movq %r12, -0x18(%r12)
movq $0x1f4, ... | /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
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq %xmm0, %rax
testq %rax, %rax
jns 0x38fef
movl $0x100, 0xc(%rsp) # imm = 0x100
pxor 0x162b1(%rip), %xmm0 # 0x4f2a0
movups 0x162ba(%rip), %xmm1 # 0x4f2b0
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 %rax
leal 0x124(%rdi), %eax
cmpl $0x26b, %eax # imm = 0x26B
jae 0x39562
movl $0xffff, %ecx # imm = 0xFFFF
movl %eax, %edx
andl %ecx, %edx
imull $0x2f69, %edx, %edx # imm = 0x2F69
shrl $0x10, %edx
subl %edx, %eax
andl %ecx, %eax
shrl %eax
addl %edx, %eax
movl %eax, %edx
shrl $0x4, %edx
lea... | /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 $0xa8, %rsp
movq %rcx, %r12
movq %rdi, %r9
movq %rcx, 0xa0(%rsp)
movq (%rsi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, %rax
orq $0x1, %rax
bsrq %rax, %rax
leaq 0x17be7(%rip), %rdi # 0x51240
movzbl (%rax,%rdi), %eax
leaq 0x17c1c(%rip), %rdi # 0x... | /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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x39d8a
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x154b2(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x39e2b
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x15411(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r8)
je 0x39fbb
movq %r8, %r14
leaq 0x40(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0x243f0(%rip), %rax # 0x5e340
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0x1f4, -0x8(%r15) ... | /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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0x3a12a
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x1518e(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx),... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_significand<fmt::v9::appender, char, unsigned long, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned long, 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 %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %ecx, %ebp
movl %edx, %ecx
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0x3a203
movq %r9, %r14
leaq 0x40(%rsp), %r12
movq $0x0, -0x10(%r12)
leaq 0x241c3(%rip), %rax # 0x5e340
movq %rax, -0x20(%r12)
movq %r12... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::float_specs fmt::v9::detail::parse_float_type_spec<fmt::v9::detail::error_handler, char>(fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::error_handler&&) | FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char>& specs,
ErrorHandler&& eh = {})
-> float_specs {
auto result = float_specs();
result.showpoint = specs.alt;
result.locale = specs.localized;
switch (specs.type) {
case presentation_type::none:
... | movzbl 0x8(%rdi), %edx
cmpq $0xe, %rdx
ja 0x3a8da
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x1, %ecx
movl %ecx, %esi
shll $0x13, %esi
shll $0x9, %eax
andl $0x20000, %eax # imm = 0x20000
orl %esi, %eax
leaq 0x14ad6(%rip), %rsi # 0x4f350
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%r... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
int fmt::v9::detail::snprintf_float<long double>(long double, int, fmt::v9::detail::float_specs, fmt::v9::detail::buffer<char>&) | auto snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) -> int {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
FMT_ASSERT(specs.format == float_format::hex, "");
static_assert(!s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
fldt 0x60(%rsp)
fstpt 0x1c(%rsp)
movq 0x18(%rdx), %rax
cmpq 0x10(%rdx), %rax
jbe 0x3aa21
movabsq $0xff00000000, %rax # imm = 0xFF00000000
andq %rsi, %rax
movabsq $0x300000000, %rcx # imm = 0x300000000
cmpq %rcx, %rax
jne 0x3aa39... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)2, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(char, fmt::v... | 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
movslq (%rsi), %rax
testq %rax, %rax
js 0x3ad87
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x144c0(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r15, %r13
s... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::format_dragon(fmt::v9::detail::basic_fp<unsigned __int128>, unsigned int, int, fmt::v9::detail::buffer<char>&, int&) | FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
unsigned flags, int num_digits,
buffer<char>& buf, int& exp10) {
bigint numerator; // 2 * R in (FPP)^2.
bigint denominator; // 2 * S in (FPP)^2.
// lower and... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movl %esi, %ebp
leaq 0x350(%rsp), %rbx
xorl %eax, %eax
leaq 0x58(%rsp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x235ec(%rip), %rdx # 0x5e3c0
movq %rdx, (%rcx)
movl $0x20, %esi
l... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::operator<<=(int) | bigint& operator<<=(int shift) {
FMT_ASSERT(shift >= 0, "");
exp_ += shift / bigit_bits;
shift %= bigit_bits;
if (shift == 0) return *this;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
bigit c = bigits_[i] >> (bigit_bits - shift);
bigits_[i] = (bigits_[i] << ... | pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x3b5f8
movq %rdi, %rbx
movl %esi, %eax
shrl $0x5, %eax
addl %eax, 0xa8(%rdi)
andl $0x1f, %esi
je 0x3b5ee
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x3b5ee
movq 0x8(%rbx), %rdi
movl $0x20, %eax
subl %esi, %eax
xorl %r8d, %r8d
xorl %ebp, %ebp
movl %ebp, %r9d
movl (%rd... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::assign_pow10(int) | FMT_CONSTEXPR20 void assign_pow10(int exp) {
FMT_ASSERT(exp >= 0, "");
if (exp == 0) return *this = 1;
// Find the top bit.
int bitmask = 1;
while (exp >= bitmask) bitmask <<= 1;
bitmask >>= 1;
// pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
// repeated squaring... | pushq %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x3b68e
movq %rdi, %rbx
je 0x3b67d
movl %esi, %ebp
movl $0x1, %eax
movl %eax, %r14d
leal (%r14,%r14), %eax
cmpl %ebp, %r14d
jle 0x3b624
movl $0x5, %esi
movq %rbx, %rdi
callq 0x3bb0c
cmpl $0x4, %r14d
jb 0x3b66f
shrl $0x2, %r14d
movq %rbx, %rdi
callq 0x3bb60
testl %ebp... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::assign(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 void assign(const bigint& other) {
auto size = other.bigits_.size();
bigits_.resize(size);
auto data = other.bigits_.data();
std::copy(data, data + size, make_checked(bigits_.data(), size));
exp_ = other.exp_;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
cmpq %r15, 0x18(%rdi)
jae 0x3b6d7
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
movq 0x18(%rbx), %rax
cmpq %r15, %rax
cmovaeq %r15, %rax
movq %rax, 0x10(%rbx)
jmp 0x3b6e0
movq %r15, 0x10(%rbx)
testq %r15, %r15
je 0x... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::add_compare(fmt::v9::detail::bigint const&, fmt::v9::detail::bigint const&, fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 int num_bigits() const {
return static_cast<int>(bigits_.size()) + exp_;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0xa8(%rdi), %ecx
movl 0x10(%rdi), %r8d
addl %ecx, %r8d
movl 0xa8(%rsi), %r9d
movl 0x10(%rsi), %r10d
addl %r9d, %r10d
cmpl %r10d, %r8d
movl %r10d, %eax
cmovgl %r8d, %eax
movl 0x10(%rdx), %r14d
movl 0xa8(%rdx), %r11d
leal (%r11,%r14),... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::divmod_assign(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
FMT_ASSERT(this != &divisor, "");
if (compare(*this, divisor) < 0) return 0;
FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
align(divisor);
int quotient = 0;
do {
subtract_aligned(divisor);
++quotient;
... | pushq %rbp
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0x3b927
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3b957
testl %eax, %eax
js 0x3b91e
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpl $0x0, -0x4(%rax,%rcx,4)
je 0x3b93f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bf78
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::compare(fmt::v9::detail::bigint const&, fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
if (num_lhs_bigits != num_rhs_bigits)
return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
int i = static_cast<int>(lhs.bigits_.size()) - 1;
int j = static_cast... | pushq %rax
movq 0x10(%rdi), %r8
movl 0xa8(%rdi), %ecx
addl %r8d, %ecx
movq 0x10(%rsi), %rax
movl 0xa8(%rsi), %edx
addl %eax, %edx
cmpl %edx, %ecx
jne 0x3b9b8
movl %r8d, %ecx
movl %eax, %edx
subl %eax, %r8d
xorl %eax, %eax
testl %r8d, %r8d
cmovgl %r8d, %eax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
cmpl %ecx, %eax
jge 0... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::grow(unsigned long) | FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > ne... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
addq $0xa0, %rdi
movq 0x18(%r14), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jae 0x3ba1a
movq %rsi, %r15
jmp 0x3ba34
movq %r15, %rax
shrq $0x3d, %rax
je 0x3ba34
movabsq $0x1fffffffffffffff, %r15 # imm = 0x1FFFFFFFFFFFFFFF
cmpq %r... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::bigint::assign<unsigned __int128, 0>(unsigned __int128) | FMT_CONSTEXPR20 void assign(UInt n) {
size_t num_bigits = 0;
do {
bigits_[num_bigits++] = static_cast<bigit>(n);
n >>= bigit_bits;
} while (n != 0);
bigits_.resize(num_bigits);
exp_ = 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
xorl %r14d, %r14d
movl %esi, (%rax,%r14,4)
shrdq $0x20, %rdx, %rsi
incq %r14
shrq $0x20, %rdx
movq %rsi, %rcx
orq %rdx, %rcx
jne 0x3baba
movq 0x18(%rbx), %rax
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
ja 0x3baee
movq (%rbx), %rax
movq %rbx, %rdi
movq %r1... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::bigint::assign<unsigned long, 0>(unsigned long) | FMT_CONSTEXPR20 void assign(UInt n) {
size_t num_bigits = 0;
do {
bigits_[num_bigits++] = static_cast<bigit>(n);
n >>= bigit_bits;
} while (n != 0);
bigits_.resize(num_bigits);
exp_ = 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
xorl %r14d, %r14d
movl %esi, (%rax,%r14,4)
incq %r14
shrq $0x20, %rsi
jne 0x3bb1a
movq 0x18(%rbx), %rax
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
ja 0x3bb43
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x18(%rbx), %rax
cmpq %r14, ... | /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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
movq 0x8(%rdi), %rax
movq %rcx, %r14
cmpl $0x2, %r14d
jl 0x3bd5f
leaq -0x1(%r14), %rcx
cmpl $0x0, -0x4(%rax,%r14,4)
je 0x3bd48
jmp 0x3bd64
testl %r14d, %r14d
js 0x3bd8f
movq 0x18(%rbx), %rax
cmpq %r14, %rax
jae 0x3bd7c
movq (%rbx), %rax
movq %rbx, %... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v9::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&) | FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
alloc_ = std::move(other.alloc_);
T* data = other.data();
size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
detail::copy_str<T>(other.store_, other.store_ + size,
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rax
leaq 0x20(%rsi), %rcx
cmpq %rcx, %rdx
je 0x3bde0
movq %rdx, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq %rcx, 0x8(%rsi)
addq $0x10, %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq 0x18(%rbx), %rax
jmp 0x3be0c
le... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::bigint::multiply<unsigned __int128, 0>(unsigned __int128) | constexpr auto size() const noexcept -> size_t { return size_; } | movq 0x10(%rdi), %r9
testq %r9, %r9
je 0x3bf0e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rdi, %rbx
movq 0x8(%rdi), %r10
movq %rdx, %r11
shrq $0x20, %r11
shlq $0x20, %rcx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%r10,%r12,4), %r8d
movq %r8, %rax... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
fmt::v9::detail::bigint::multiply(unsigned int) | constexpr auto size() const noexcept -> size_t { return size_; } | movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3bf77
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %ecx
movq 0x8(%rdi), %rdx
xorl %esi, %esi
xorl %r14d, %r14d
movl (%rdx,%rsi,4), %edi
imulq %rcx, %rdi
addq %rdi, %r14
movl %r14d, (%rdx,%rsi,4)
shrq $0x20, %r14
incq %rsi
cmpq %rsi, %rax
jne 0x3bf2b
testq %r14,... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
fmt::v9::detail::bigint::align(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 void align(const bigint& other) {
int exp_difference = exp_ - other.exp_;
if (exp_difference <= 0) return;
int num_bigits = static_cast<int>(bigits_.size());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0xa8(%rdi), %r15d
subl 0xa8(%rsi), %r15d
jle 0x3c01c
movq %rdi, %rbx
movl 0x10(%rdi), %r12d
movl %r15d, %eax
addl %r12d, %eax
js 0x3c028
movl %eax, %r14d
movq 0x18(%rbx), %rax
cmpq %r14, %rax
jae 0x3bfc2
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::subtract_aligned(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) {
FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
FMT_ASSERT(compare(*this, other) >= 0, "");
bigit borrow = 0;
int i = other.exp_ - exp_;
for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
subtract_bigits(i, other.big... | pushq %r14
pushq %rbx
pushq %rax
movl 0xa8(%rsi), %eax
cmpl 0xa8(%rdi), %eax
jl 0x3c110
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3b957
testl %eax, %eax
js 0x3c128
movq 0x10(%r14), %rcx
testq %rcx, %rcx
je 0x3c0e9
movl 0xa8(%r14), %eax
subl 0xa8(%rbx), %eax
movq 0x8(%r14), %rsi
leaq (,%rax,4), %rdi
addq 0x8(%rbx), %rdi
x... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref) | 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 $0xa8, %rsp
movq %rdx, %r10
movq %rcx, 0xa0(%rsp)
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rsi), %edx
movl %edx, 0xc(%rsp)
movb $0x30, 0x7(%rsp)
movq %rcx, %rax
shrq $0x28, %rax
movb %al, 0x6(%rsp)
testl %edx, %edx
js 0x3c5c0
movq %rcx, %r1... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::big_decimal_fp 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::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fm... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0x3c855
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x12a93(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx),... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_significand<fmt::v9::appender, char>(fmt::v9::appender, char const*, int, int, char) | FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
int significand_size, int integral_size,
Char decimal_point) -> OutputIt {
out = detail::copy_str_noinline<Char>(significand,
si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rdx
movslq %ecx, %r15
addq %rsi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3c8f2
movq %rax, %r12
testb %bpl, %bpl
je 0x3c8e6
movq 0x10(%r12), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r12)
jae 0x3c8bc... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::big_decimal_fp 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::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fm... | 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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x3c992
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x128aa(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_significand<char, fmt::v9::appender, char const*, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, char const*, 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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r8)
je 0x3cb14
movq %r8, %r14
leaq 0x30(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0x2188e(%rip), %rax # 0x5e340
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0x1f4, -0x8(%r15) ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::big_decimal_fp 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::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fm... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0x3cc75
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x12643(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx),... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::big_decimal_fp 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::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fm... | 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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x3ce20
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x1241c(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_ptr<char, fmt::v9::appender, unsigned long>(fmt::v9::appender, unsigned long, fmt::v9::basic_format_specs<char> const*) | auto write_ptr(OutputIt out, UIntPtr value,
const basic_format_specs<Char>* specs) -> OutputIt {
int num_digits = count_digits<4>(value);
auto size = to_unsigned(num_digits) + size_t(2);
auto write = [=](reserve_iterator<OutputIt> it) {
*it++ = static_cast<Char>('0');
*it++ = static_cast<Ch... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rsi, %rcx
movq %rsi, %rax
shrq $0x4, %rax
incq %r15
cmpq $0xf, %rcx
movq %rax, %rcx
ja 0x3cf9d
movq %r14, (%rsp)
movl %r15d, 0x8(%rsp)
testq %rdx, %rdx
je 0x3cfd8
addq $0x2, %r15
movq %rsp, %r8
movq %rbx, %rdi
movq... | /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, fmt::v9::appender fmt::v9::detail::write_ptr<char, fmt::v9::appender, unsigned long>(fmt::v9::appender, unsigned long, fmt::v9::basic_format_specs<char> const*)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::ba... | 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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0x3d274
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x11fc8(%rip), %rcx # 0x4f1e4
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char const* fmt::v9::detail::parse_replacement_field<char, void fmt::v9::detail::vformat_to<char>(fmt::v9::detail::buffer<char>&, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<std::conditional<std::is_same<fmt::v9::type_identity<char>::type, char>::value, fmt::v9::appender, ... | FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
struct id_adapter {
Handler& handler;
int arg_id;
FMT_CONSTEXPR void operator()() { arg_id = handler.on_arg_id(); }
FMT_CONSTEXPR void operator... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
leaq 0x1(%rdi), %rbx
cmpq %rsi, %rbx
je 0x3d690
movq %rdx, %r12
movzbl (%rbx), %eax
cmpl $0x7b, %eax
je 0x3d38a
cmpl $0x7d, %eax
jne 0x3d3a8
movl 0x18(%r12), %edx
testl %edx, %edx
js 0x3d69c
leal 0x1(%rdx), %eax
movl %eax... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.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.