name string | code string | asm string | file string |
|---|---|---|---|
mbedtls_sha1_finish | void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, msglen, 0 );
PUT_UINT3... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x1d, %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, -0x20(%rbp... | /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_sha512_finish | void mbedtls_sha512_finish( mbedtls_sha512_context *ctx, unsigned char output[64] )
{
size_t last, padn;
uint64_t high, low;
unsigned char msglen[16];
high = ( ctx->total[0] >> 61 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT64_BE( high, msglen, 0 );
PUT_UI... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x3d, %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shlq $0x3, %rax
movq %rax, -0x30(%rbp... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_asn1_get_int | int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
if( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x2, %ecx
callq 0x15cb0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x15dfa
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15e76
c... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_sequence_of | int mbedtls_asn1_get_sequence_of( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_sequence *cur,
int tag)
{
int ret;
size_t len;
mbedtls_asn1_buf *buf;
/* Get main sequence tag */
if( ( ret = mbedtls_asn1_get_ta... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x30, %ecx
callq 0x15cb0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0x160a0
movl -0x28(%rbp), %eax
movl %eax, ... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_mpi_safe_cond_assign | int mbedtls_mpi_safe_cond_assign( mbedtls_mpi *X, const mbedtls_mpi *Y, unsigned char assign )
{
int ret = 0;
size_t i;
/* make sure assign is 0 or 1 in a time-constant manner */
assign = (assign | (unsigned char)-assign) >> 7;
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
X->s = X->s * ( 1... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movzbl -0x11(%rbp), %eax
movzbl -0x11(%rbp), %edx
xorl %ecx, %ecx
subl %edx, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
sarl $0x7, %eax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rd... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_bitlen | size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X )
{
size_t i, j;
if( X->n == 0 )
return( 0 );
for( i = X->n - 1; i > 0; i-- )
if( X->p[i] != 0 )
break;
j = biL - mbedtls_clz( X->p[i] );
return( ( i * biL ) + j );
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16f11
movq $0x0, -0x8(%rbp)
jmp 0x16f81
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x16f4d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_add_int | int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_add_mpi( X, A, &_B ) );
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x173f7
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x173ff
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mpi_write_hlp | static int mpi_write_hlp( mbedtls_mpi *X, int radix, char **p )
{
int ret;
mbedtls_mpi_uint r;
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, radix ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_div_int( X, NULL, X, radix ) );
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jl 0x1774f
cmpl $0x10, -0x14(%rbp)
jle 0x1775b
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1781d
jmp 0x1775d
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq -0x30(%rbp),... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_cmp_mpi | int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
for( i = X->n; i > 0; i-- )
if( X->p[i - 1] != 0 )
break;
for( j = Y->n; j > 0; j-- )
if( Y->p[j - 1] != 0 )
break;
if( i == 0 && j == 0 )
return( 0 );
if( i > j )... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x181b8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x181a8
jmp 0x181b8
jmp 0x181aa
m... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_mod_int | int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
size_t i;
mbedtls_mpi_uint x, y, z;
if( b == 0 )
return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
if( b < 0 )
return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
/*
* handle trivial cases
*/
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x198f3
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
jmp 0x19a45
cmpq $0x0, -0x20(%rbp)
jge 0x19906
movl $0xfffffff6, -0x4(%rbp) # imm = 0xFFFFFFF6
jmp 0x19a45
cmpq $0x1, -0x20(%rbp)
jne 0x19924... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_cipher_info_from_values | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_bitlen,
const mbedtls_cipher_mode_t mode )
{
const mbedtls_cipher_definition_t *def;
for( def = mbedtls_cipher_d... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1cc7c(%rip), %rax # 0x38bc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1bfa4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jn... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_setup | int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
{
if( NULL == cipher_info || NULL == ctx )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_a... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1c0a0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1c0a9
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1c0fc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x80c0
... | /Dragonchang[P]https_client/mbedtls/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;
size_t block_size = 0;
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1c4ff
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1c4ff
xorl %eax, %eax
cmpq ... | /Dragonchang[P]https_client/mbedtls/library/cipher.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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1ca2f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1ca2f
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1ca3b
movl $0xffff9f00, -0x4(%rbp) # imm = 0... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_write_tag | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1d26f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1d26f
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1d278
movl $0xffff9f00, -0x4(%rbp) # imm = 0... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_md5_self_test | int mbedtls_md5_self_test( int verbose )
{
int i;
unsigned char md5sum[16];
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
mbedtls_printf( " MD5 test #%d: ", i + 1 );
mbedtls_md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
if( memcmp( md5sum, md5_test_sum[i], 1... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x239c5
cmpl $0x0, -0x8(%rbp)
je 0x23926
movl -0xc(%rbp), %esi
addl $0x1, %esi
leaq 0xc051(%rip), %rdi # 0x2f970
movb $0x0, %al
callq 0x8090
movslq -0xc(%rbp), %rax
leaq 0xc05f(%rip), %rdi # 0x2f9... | /Dragonchang[P]https_client/mbedtls/library/md5.c |
BamTools::Internal::BamReaderPrivate::LoadReferenceData() | bool BamReaderPrivate::LoadReferenceData()
{
// get number of reference sequences
char buffer[sizeof(uint32_t)];
m_stream.Read(buffer, sizeof(uint32_t));
uint32_t numberRefSeqs = BamTools::UnpackUnsignedInt(buffer);
if (m_isBigEndian) BamTools::SwapEndian_32(numberRefSeqs);
m_references.reserve... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r13
leaq 0x1e8(%rdi), %r14
leaq 0xc(%rsp), %r15
pushq $0x4
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4b21a
movl (%r15), %eax
movl %eax, %ebx
bswapl %ebx
cmpb $0x0, 0x40(%r13)
cmovel %eax, %ebx
leaq 0x2... | /alok123t[P]HyINDEL/external/bamtools/src/api/internal/bam/BamReader_p.cpp |
main | int main(int argc, char ** argv)
{
// Instantiate Argengine and give it the raw argument data.
Argengine ae(argc, argv);
// Add a minimal dummy option "foo".
ae.addOption(
{ "foo" }, [] {
std::cout << "Foo enabled!" << std::endl;
});
// Add a minimal dummy option "bar".
a... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rsi, %rdx
movl %edi, %esi
leaq 0x8(%rsp), %rdi
movl $0x1, %ecx
callq 0x20e0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xcd4(%rip), %rsi # 0x3004
leaq 0xcd0(%rip), %rdx # 0x3007
leaq 0x10(%rsp), %r... | /juzzlin[P]Argengine/src/examples/ex2/ex2.cpp |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x10a0
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /mitls[P]mitls-curl/tests/libtest/first.c |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x10d0
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /devkitPro[P]curl/tests/libtest/first.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x1bb7
xorl %ebx, %ebx
jmp 0x1c01
movq %rsi, %r14
testq %rsi, %rsi
je 0x1bfa
movq %rdi, %r15
leaq 0x2547(%rip), %rbx # 0x4110
leaq 0x795(%rip), %r12 # 0x2365
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %... | /devkitPro[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x717(%rip), %rsi # 0x2339
movl $0x6, %edi
callq 0x10a0
cmpl $0x1, %ebp
jg 0x1c55
movq 0x23a8(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x729(%rip), %rsi # 0x236b
xorl %eax, %eax
callq 0x1140
movl $0x1, %eax
addq $0x8, %rsp
popq %r... | /devkitPro[P]curl/tests/libtest/first.c |
tutil_tvdiff | long tutil_tvdiff(struct timeval newer, struct timeval older)
{
return (long)(newer.tv_sec-older.tv_sec)*1000+
(long)(newer.tv_usec-older.tv_usec)/1000;
} | movq %rsi, %rax
subq %rdx, %rdi
subq %rcx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
imulq $0x3e8, %rdi, %rcx # imm = 0x3E8
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rdx, %rax
addq %rcx, %rax
retq
| /devkitPro[P]curl/tests/libtest/testutil.c |
curlx_ultosi | int curlx_ultosi(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma war... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /devkitPro[P]curl/lib/warnless.c |
curlx_uztosi | int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /devkitPro[P]curl/lib/warnless.c |
graph::isEdge(restaurant*, restaurant*) | bool graph::isEdge(restaurant *from, restaurant *to)
{
if (v.find(mapper[from]) == v.end() || v.find(mapper[to]) == v.end())
{
return false;
}
vector<pair<int, int>> adj = theGraph[mapper[from]];
for (int i = 0; i < adj.size(); i++)
{
if (adj[i].first == mapper[to])
{
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
addq $0x68, %rdi
leaq -0x18(%rbp), %rsi
callq 0x17040
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x170d... | /mmhobi7[P]UPick/graph.cpp |
graph::getAdjacent(restaurant*) | vector<restaurant *> graph::getAdjacent(restaurant *vertex)
{
vector<restaurant *> adj;
if (v.find(mapper[vertex]) == v.end())
{
return adj;
}
vector<pair<int, int>> list = theGraph[mapper[vertex]];
for (int i = 0; i < list.size(); i++)
{
// find vertex to add
int ke... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x146a0
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %r... | /mmhobi7[P]UPick/graph.cpp |
smf::MidiMessage::isSoftOff() const | bool MidiMessage::isSoftOff(void) const {
if (!isSoft()) {
return false;
}
if (getP2() < 64) {
return true;
} else {
return false;
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x1f980
testb %al, %al
je 0x1f9fc
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
movb $0x1, %al
cmpq $0x3, %rdx
jb 0x1f9fe
cmpb $0x40, 0x2(%rcx)
setb %al
jmp 0x1f9fe
xorl %eax, %eax
popq %rbx
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::isLyricText() const | bool MidiMessage::isLyricText(void) const {
if (!isMetaMessage()) {
return false;
} else if ((*this)[1] != 0x05) {
return false;
} else {
return true;
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x1f7f8
testb %al, %al
je 0x1fb1f
movq (%rbx), %rax
cmpb $0x5, 0x1(%rax)
sete %al
jmp 0x1fb21
xorl %eax, %eax
popq %rbx
retq
nop
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::setCommand(int, int, int) | void MidiMessage::setCommand(int value, int p1, int p2) {
this->resize(3);
(*this)[0] = (uchar)value;
(*this)[1] = (uchar)p1;
(*this)[2] = (uchar)p2;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x3
popq %rsi
callq 0x1e97e
movq (%r15), %rax
movb %r14b, (%rax)
movq (%r15), %rax
movb %bpl, 0x1(%rax)
movq (%r15), %rax
movb %bl, 0x2(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq ... | /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::Binasc::processVlvWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processVlvWord(std::ostream& out, const std::string& word,
int lineNum) {
if (word.size() < 2) {
std::cerr << "Error on line: " << lineNum
<< ": 'v' needs to be followed immediately by a decimal digit"
<< std::endl;
return 0;
}
if (!isdigit(word[1])) {
std::cerr << "Error on line: " << ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
cmpq $0x1, 0x8(%rdx)
jbe 0x234cf
movq (%rdx), %rdi
movsbl 0x1(%rdi), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x234cf
movq %rsi, %rbx
incq %rdi
callq 0x16450
movl %eax, %ecx
sarl $0x1c, %ecx
andb $0x7f, %cl
movb %cl, 0xb(%rsp)
movl %eax, %ecx
shrl $0x1... | /craigsapp[P]midifile/src/Binasc.cpp |
smf::Binasc::processMidiPitchBendWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processMidiPitchBendWord(std::ostream& out, const std::string& word,
int lineNum) {
if (word.size() < 2) {
std::cerr << "Error on line: " << lineNum
<< ": 'p' needs to be followed immediately by "
<< "a floating-point number" << std::endl;
return 0;
}
if (!(isdigit(word[1]) || word[1] == ... | pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
cmpq $0x1, 0x8(%rdx)
ja 0x23592
movq 0x13aa1(%rip), %rdi # 0x36ff0
leaq 0x7dc5(%rip), %rsi # 0x2b31b
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7e3c(%rip), %rsi # 0x2b3a8
movq %rax, %rdi
callq 0x16290
leaq 0x7e15(%rip), %rsi # 0... | /craigsapp[P]midifile/src/Binasc.cpp |
smf::Binasc::processDecimalWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processDecimalWord(std::ostream& out, const std::string& word,
int lineNum) {
int length = (int)word.size(); // length of ascii binary number
int byteCount = -1; // number of bytes to output
int quoteIndex = -1; // index of decimal specifier
int signIndex = -1; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, (%rsp)
movl 0x8(%rdx), %esi
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
movq (%rdx), %rax
pushq $-0x1
popq %r9
leaq 0x719e(%rip), %r10 # 0x2a8e0
movl %r9d, %r12d
movl %r9... | /craigsapp[P]midifile/src/Binasc.cpp |
smf::Binasc::processHexWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processHexWord(std::ostream& out, const std::string& word,
int lineNum) {
int length = (int)word.size();
uchar outputByte;
if (length > 2) {
std::cerr << "Error on line " << lineNum << " at token: " << word << std::endl;
std::cerr << "Size of hexadecimal number is too large. Max is ff." << std::e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movl 0x8(%rdx), %r12d
cmpl $0x3, %r12d
jl 0x24405
movq 0x12c32(%rip), %r14 # 0x36ff0
leaq 0x6a5a(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x6a50(%rip), %rsi ... | /craigsapp[P]midifile/src/Binasc.cpp |
smf::Binasc::keyToPitchName[abi:cxx11](int) | std::string Binasc::keyToPitchName(int key) {
int pc = key % 12;
int octave = key / 12 - 1;
std::stringstream output;
switch (pc) {
case 0: output << "C"; break;
case 1: output << "C#"; break;
case 2: output << "D"; break;
case 3: output << "D#"; break;
case 4: output << "E"; break;
case 5: out... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movl %esi, %eax
movq %rdi, %rbx
pushq $0xc
popq %rcx
cltd
idivl %ecx
movl %edx, %r14d
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x161e0
cmpl $0xc, %r14d
jae 0x2537c
movl %r14d, %eax
leaq 0x5675(%rip), %rcx # 0x2a9e0
movslq (%rcx,%rax,4),... | /craigsapp[P]midifile/src/Binasc.cpp |
smf::Binasc::writeBigEndianULong(std::ostream&, unsigned long) | std::ostream& Binasc::writeBigEndianULong(std::ostream& out, ulong value) {
union { char bytes[4]; long ul; } data;
data.ul = value;
out << data.bytes[3];
out << data.bytes[2];
out << data.bytes[1];
out << data.bytes[0];
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl %r14d, %ebp
shrl $0x8, %ebp
movl %r14d, %r15d
shrl $0x10, %r15d
sarl $0x18, %esi
callq 0x162e0
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x162e0
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x162e0
movsbl %r14b, %esi
movq %rbx, %rdi
c... | /craigsapp[P]midifile/src/Binasc.cpp |
smf::MidiEvent::linkEvent(smf::MidiEvent*) | void MidiEvent::linkEvent(MidiEvent* mev) {
if (mev->m_eventlink != NULL) {
// unlink other event if it is linked to something else;
mev->unlinkEvent();
}
// if this is already linked to something else, then unlink:
if (m_eventlink != NULL) {
m_eventlink->unlinkEvent();
}
unlinkEvent();
mev->m_eventlink =... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x30(%rsi)
je 0x25ab9
movq %rbx, %rdi
callq 0x25a8c
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x25ac7
callq 0x25a8c
movq %r14, %rdi
callq 0x25a8c
movq %r14, 0x30(%rbx)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /craigsapp[P]midifile/src/MidiEvent.cpp |
njoy::ENDFtk::section::DerivedRedundant::DerivedRedundant(double, double, std::vector<double, std::allocator<double>>&&, std::vector<int, std::allocator<int>>&&) | DerivedRedundant( double e1, double e2,
std::vector< double >&& coefficients,
std::vector< int >&& reactions )
try :
list_(
ListRecord( e1, e2, 0, 0, coefficients.size(),
generateList( std::move( coefficients ),
std::move( reactions... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r14
leaq 0x18(%rsp), %rdi
callq 0x1d6d8
subq %r15, %r14
sarq $0x3, %r14
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq %r1... | /njoy[P]ENDFtk/src/ENDFtk/section/DerivedRedundant/src/ctor.hpp |
njoy::ENDFtk::section::Type<31>::Type<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(njoy::ENDFtk::HeadRecord&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_... | Type( HEAD& head,
Iterator& begin,
const Iterator& end,
long& lineNumber,
int MAT )
try:
Base( head, MAT, 31 ),
reactions_(
readSequence< ReactionBlock >( begin, end, lineNumber,
MAT, 31, head.MT(), head.N2() ) ) {
readSEND(begin, end, lin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
movl %r9d, %edx
movl $0x1f, %ecx
callq 0x30db4
addq $0x18, %r15
movl (%r14), %eax
movl 0x38(%r14), %r10d
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, ... | /njoy[P]ENDFtk/src/ENDFtk/section/31/src/ctor.hpp |
njoy::ENDFtk::tree::Section::Section<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(njoy::ENDFtk::HeadRecord const&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__nor... | Section( const HEAD& head, BufferIterator begin,
BufferIterator& position, const BufferIterator& end,
long& lineNumber )
try: Section( head.MAT(), head.MF(), head.MT(),
std::string( begin, findEnd( position, end, lineNumber ) ) ) {}
catch( std::exception& e ) {
Log::info( "Tro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movsd 0x30(%rsi), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x38(%rsi), %ebp
movq %rcx, %rdi
movq %r8, %rsi
movq %r9, %rdx
callq 0x34418
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13... | /njoy[P]ENDFtk/src/ENDFtk/tree/Section/src/ctor.hpp |
fmt::v9::appender fmt::v9::detail::default_arg_formatter<char>::operator()<void const*>(void const*) | auto operator()(T value) -> iterator {
return write<Char>(out, value);
} | subq $0x18, %rsp
movq (%rdi), %rdi
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movb $0x0, 0x8(%rdx)
movw $0x0, 0x9(%rdx)
movl $0x20, 0xb(%rdx)
movb $0x1, 0xf(%rdx)
xorl %ecx, %ecx
callq 0x24ce1
addq $0x18, %rsp
retq
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::buffer<char>::append<char>(char const*, char const*) | void buffer<T>::append(const U* begin, const U* end) {
while (begin != end) {
auto count = to_unsigned(end - begin);
try_reserve(size_ + count);
auto free_cap = capacity_ - size_;
if (free_cap < count) count = free_cap;
std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
... | cmpq %rdx, %rsi
je 0x1e568
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movq %rbx, %r13
subq %r14, %r13
leaq (%rdi,%r13), %rsi
movq 0x18(%r15), %r12
cmpq %rsi, %r12
jae 0x1e52e
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x10(%r15)... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1e966
movslq %eax, %rdx
movq 0x10(%rbx), %rcx
addq %rcx, %rdx
cmpq %rdx, 0x18(%rbx)
jb 0x1ea5c
movq %rdx, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1ea5c
addq ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
bool 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::locale_ref) | auto write_int_localized(OutputIt& out, UInt value, unsigned prefix,
const basic_format_specs<Char>& specs, locale_ref loc)
-> bool {
auto grouping = digit_grouping<Char>(loc);
out = write_int_localized(out, value, prefix, specs, grouping);
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r8, %rsi
movl $0x1, %edx
callq 0x1f258
movq (%rbx), %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %r12, %r8
callq 0x1f346
movq %r... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x1f5c6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f5f0
testq %r14, %r14
je 0x1f5e1
addq %rbx, %r12
movq ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::fill_n<fmt::v9::appender, unsigned long, char>(fmt::v9::appender, unsigned long, char const&) | FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-> OutputIt {
for (Size i = 0; i < count; ++i) *out++ = value;
return out;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1f633
movq %rdx, %rbx
movq %rsi, %r15
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r14)
jae 0x1f621
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
movb (%rbx), %cl
movq 0x8(%r14), %rdx
movq ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7b5b8(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
char fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)1, 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
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7ac04(%rip), %rcx # 0x9afa5
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r13
movq %rdi, %r12
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x20432
movl $0x100, 0xc(%rsp) # imm = 0x100
pxor 0x78c5e(%rip), %xmm0 # 0x99090
movups 0x78d27(%rip), %xmm1 # 0x99160
movaps %xmm1, 0x10(%rsp)
movd %xmm0, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFF... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x204d5
movb $0x20, 0x13(%rsp)
btl $0x10, %eax
leaq 0x79b1b(%rip), %rcx # 0x99ffb... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.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 $0xb8, %rsp
movq %rcx, %r14
movq %rdi, %r9
movq %rcx, 0x68(%rsp)
movl (%rsi), %r11d
movl %r11d, 0xc(%rsp)
movl %r11d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x7ab20(%rip), %rcx # 0x9b160
movq %r11, %r15
addq (%rcx,%rax,8), %r15
shrq $0x20, %r1... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::fill_n<fmt::v9::appender, int, char>(fmt::v9::appender, int, char const&) | FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-> OutputIt {
for (Size i = 0; i < count; ++i) *out++ = value;
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testl %esi, %esi
jle 0x20d9b
movq %rdx, %rbx
movl %esi, %ebp
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r14)
jae 0x20d8a
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
movb (%rbx), %cl
movq 0x8(%r14), %rdx
movq... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7a06e(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::basic_memory_buffer<char, 500ul, std::allocator<char>>::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
movq 0x18(%rdi), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jb 0x211a4
testq %r15, %r15
jns 0x211ac
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %rsi
cmovbeq %rax, %rsi
movq %rsi, %r15
testq %rsi, %rsi
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x79d75(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi,... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0x213b2
movq %r9, %r14
leaq 0x30(%rsp), %r13
movq $0x0, -0x10(%r13)
leaq 0xb6dac(%rip), %rax # 0xd80f0
movq %rax, -0x20(%r13)
movq %r13, -0x18(%r13)
mo... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x79a32(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x216fd
movl $0x100, 0xc(%rsp) # imm = 0x100
pxor 0x779a3(%rip), %xmm0 # 0x990a0
movups 0x77a5c(%rip), %xmm1 # 0x99160
movaps %xmm1, 0x10(%rsp)
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x79092(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x220e3
movq %r8, %r14
leaq 0x40(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0xb6078(%rip), %rax # 0xd80f0
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0x1f4, -0x8(%r15) ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x78e32(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi,... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x22313
movq %r9, %r14
leaq 0x40(%rsp), %r13
movq $0x0, -0x10(%r13)
leaq 0xb5e66(%rip), %rax # 0xd80f0
movq %rax, -0x20(%r13)
movq %r13... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x78a95(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 0x229b8
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 0x768ac(%rip), %rsi # 0x99204
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%r... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.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
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7822e(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r13
movq %rdi, %r12
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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
movq %rsi, %rbx
movq %rdi, %r14
callq 0x23893
testl %eax, %eax
js 0x2388a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23e7a
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23f1c
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23893
testl %eax, %eax
jns 0x2386c
jmp 0x2388c
xorl %eb... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::compare(fmt::v9::detail::bigint const&, fmt::v9::detail::bigint const&) | constexpr auto size() const noexcept -> size_t { return size_; } | movq 0x10(%rdi), %r8
movl 0xa8(%rdi), %eax
addl %r8d, %eax
movl 0x10(%rsi), %ecx
movl 0xa8(%rsi), %edx
addl %ecx, %edx
cmpl %edx, %eax
jne 0x238e9
movl %r8d, %edx
subl %ecx, %r8d
xorl %eax, %eax
testl %r8d, %r8d
cmovgl %r8d, %eax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
cmpl %edx, %eax
jge 0x238f1
decl %ecx
movl -0x4(... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.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 0x23930
movq %rsi, %r15
jmp 0x2394a
movq %r15, %rax
shrq $0x3d, %rax
je 0x2394a
movabsq $0x1fffffffffffffff, %r15 # imm = 0x1FFFFFFFFFFFFFFF
cmpq %r... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/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 __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x731fb(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
spdlog::logger::logger<std::shared_ptr<spdlog::sinks::sink> const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<spdlog::sinks::sink> const*, std::shared_ptr<spdlog::sinks::sink> const*) | logger(std::string name, It begin, It end)
: name_(std::move(name))
, sinks_(begin, end)
{} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9aba1(%rip), %rax # 0xd8518
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rax
cmpq %rax, %rdi
je 0x3d99f
movq %rdi, 0x8(%rbx)
movq (%rax), %rdi
movq %rdi, 0x18(%rbx)
jmp 0x3d9... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/logger.h |
spdlog::sinks::base_sink<std::mutex>::log(spdlog::details::log_msg const&) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
{
std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x3dba8
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
movq %rax, %r14
mo... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::sinks::base_sink<std::mutex>::set_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
{
std::lock_guard<Mutex> lock(mutex_);
set_pattern_(pattern);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x3dc40
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
movq %rax, %r14
mo... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::sinks::base_sink<std::mutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{
std::lock_guard<Mutex> lock(mutex_);
set_formatter_(std::move(sink_formatter));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x3dcbf
movq (%r15), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq 0x8(%rsp), %rdi
testq %rd... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::sinks::base_sink<std::mutex>::set_pattern_(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
{
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3dd91
movq (%r14), %rax
movq $0x0, (%r14)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3dd34
movq (%rdi), %rax
callq *0x8(%rax)
m... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h |
spdlog::details::circular_q<spdlog::details::log_msg_buffer>::copy_moveable(spdlog::details::circular_q<spdlog::details::log_msg_buffer>&&) | void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
{
max_items_ = other.max_items_;
head_ = other.head_;
tail_ = other.tail_;
overrun_counter_ = other.overrun_counter_;
v_ = std::move(other.v_);
// put &&other in disabled, but valid state
other.max_items_... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x30(%rdi), %rax
movups 0x20(%rsi), %xmm0
movups 0x20(%rdi), %xmm1
movups %xmm0, 0x20(%rdi)
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/circular_q.h |
spdlog::details::S_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_sec, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl (%rdx), %r14d
cmpq $0x63, %r14
ja 0x449f8
movzbl %r14b, %eax
imull $0xcd, %eax, %r15d
shrl $0xb, %r15d
leal (%r15,%r15), %eax
leal (%rax,%rax,4), %eax
subb %al, %r14b
orb $0x30, %r15b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::F_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
const size_t field_size = 9;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad9(static_cast<size_t>(ns.count()),... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x18(%rsi), %r14
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %r14, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
imulq $0x3b9aca00, %rdx, %rax # imm = 0x3B9ACA00
subq %rax, %r14
movq %r14, %rax
orq $0x1, %ra... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::set_color_mode(spdlog::color_mode) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
return;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal()... | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x46439
cmpl $0x2, %esi
je 0x46435
cmpl $0x1, %esi
jne 0x46435
movq 0x1c0(%rbx), %rdi
callq 0x3a001
testb %al, %al
je 0x46435
callq 0x39f1f
jmp 0x4643b
xorl %eax, %eax
jmp 0x4643b
movb $0x1, %al
movb %al, 0x1d0(%rbx)
popq %rbx
retq
nop
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x1c8(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x4691e
movq (%r15), %rax
movq $0x0, (%r15)
movq 0x1d8(%r14), %rdi
movq %rax, 0x1d8(%r14)
testq %rdi, %rdi
je 0x46911
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
popq %rbx
po... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::set_color_mode(spdlog::color_mode) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
return;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal()... | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x46e9f
cmpl $0x2, %esi
je 0x46e9b
cmpl $0x1, %esi
jne 0x46e9b
movq 0x1c0(%rbx), %rdi
callq 0x3a001
testb %al, %al
je 0x46e9b
callq 0x39f1f
jmp 0x46ea1
xorl %eax, %eax
jmp 0x46ea1
movb $0x1, %al
movb %al, 0x1d0(%rbx)
popq %rbx
retq
nop
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::to_string_[abi:cxx11](fmt::v9::basic_string_view<char> const&) | SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
{
return std::string(sv.data(), sv.size());
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x37b20
movq %rbx, %rax
popq %rbx
retq
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::log(spdlog::details::log_msg const&) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
msg.color_range_start = 0;
msg.color_range_end = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
leaq 0x20(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0x910f3(%rip), %rax # 0xd8060
addq $0x10, %rax
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0xfa, -0x8(%r15... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::synchronous_factory>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode) | SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %edx, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f42a
movq %rbx, %rdi
movq %r15, %rsi
movq ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h |
std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode) | SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl %edx, (%r14)
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f42a
movq %rsp, %rdi
movq %r15, %rsi
mov... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h |
std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode) | SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl %edx, (%r14)
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f42a
movq %rsp, %rdi
movq %r15, %rsi
mov... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink() | ~ansicolor_sink() override = default; | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x918bf(%rip), %rax # 0xd9dc0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x2b0(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rax
movq -0x10(%r14,%r15), %rdi
cmpq %rdi, %rax
je 0x4852b
movq (%rax), %rsi
incq %rsi
callq 0x17610
addq $-0x20, %r15
cmpq $-0xe0, %r15
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::~ansicolor_sink() | ~ansicolor_sink() override = default; | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x9187d(%rip), %rax # 0xd9e00
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x2b0(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rax
movq -0x10(%r14,%r15), %rdi
cmpq %rdi, %rax
je 0x485ad
movq (%rax), %rsi
incq %rsi
callq 0x17610
addq $-0x20, %r15
cmpq $-0xe0, %r15
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink.h |
spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>::mpmc_blocking_queue(unsigned long) | explicit mpmc_blocking_queue(size_t max_items)
: q_(max_items)
{} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %r13, 0x20(%rdi)
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x178d0
leaq 0x58(%r12), %r14
movq %r14, %rdi
callq 0x178d0
incq %r... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/mpmc_blocking_q.h |
spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>::dequeue_for(spdlog::details::async_msg&, std::chrono::duration<long, std::ratio<1l, 1000l>>) | bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
{
{
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
return false;
}
popp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %rdx, (%r15)
leaq 0x8(%rsp), %r12
movq %rdi, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0x4b64e
movb $0x1, 0x8(%r12)
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/mpmc_blocking_q.h |
fmt::v9::vsystem_error(int, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<fmt::v9::appender, char>>) | FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
format_args args) {
auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(format_str, args));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, 0x4(%rsp)
movq %rdi, %r14
callq 0x172f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x4baef
movq %r14,... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::vformat[abi:cxx11](fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<fmt::v9::appender, char>>) | FMT_FUNC std::string vformat(string_view fmt, format_args args) {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
return to_string(buffer);
} | pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq $0x0, -0x10(%r14)
leaq 0x8c5d0(%rip), %rax # 0xd80e0
addq $0x10, %rax
movq %rax, -0x20(%r14)
movq %r14, -0x18(%r14)
movq $0x1f4, -0x8(%r14) # imm = 0x1F4
movq %rsp, %rdi
xorl %r9d, %r9d
callq 0x1df93
mov... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::detail::utf8_to_utf16::utf8_to_utf16(fmt::v9::basic_string_view<char>) | FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
for_each_codepoint(s, [this](uint32_t cp, string_view) {
if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
if (cp <= 0xFFFF) {
buffer_.push_back(static_cast<wchar_t>(cp));
} else {
cp -= 0x10000;
bu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x10(%rdi)
leaq 0x8e6df(%rip), %rax # 0xda290
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x1f4, 0x18(%rdi) # imm = 0x1F4
movq %rsi, %rax
cm... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::detail::thousands_sep_result<wchar_t> fmt::v9::detail::thousands_sep_impl<wchar_t>(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 $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
testq %rsi, %rsi
je 0x4ce52
callq 0x173b0
jmp 0x4ce57
callq 0x17c90
movq %rsp, %rdi
callq 0x179a0
movq %rax, %r14
movq %rsp, %rdi
callq 0x178e0
movq (%r14), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
cmpq $0x0,... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
N_VInvTestLocal_ManyVector | sunbooleantype MVAPPEND(N_VInvTestLocal)(N_Vector x, N_Vector z)
{
SUNFunctionBegin(x->sunctx);
sunindextype i;
sunbooleantype val, subval;
/* initialize output*/
val = SUNTRUE;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
/* check for nvinvtestlocal in subvector */
if (MANYVECTOR_SUBVEC(x,... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x1, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x474f
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VConstrMaskLocal_ManyVector | sunbooleantype MVAPPEND(N_VConstrMaskLocal)(N_Vector c, N_Vector x, N_Vector m)
{
SUNFunctionBegin(x->sunctx);
sunindextype i;
sunbooleantype val, subval;
/* initialize output*/
val = SUNTRUE;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
/* check for nvconstrmasklocal in subvector */
if (MA... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x48be
movq 0x28(%rsp), %rax
movq (%rax), %r... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VMinQuotientLocal_ManyVector | sunrealtype MVAPPEND(N_VMinQuotientLocal)(N_Vector num, N_Vector denom)
{
SUNFunctionBegin(num->sunctx);
sunindextype i;
sunrealtype min, lmin;
/* initialize output*/
min = SUN_BIG_REAL;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(num); i++)
{
/* check for nvminquotientlocal in subvector */
if (MANYV... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movsd 0x270c(%rip), %xmm0 # 0x7000
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x4a2d
movq 0x40(%rsp), ... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VLinearCombination_ManyVector | SUNErrCode MVAPPEND(N_VLinearCombination)(int nvec, sunrealtype* c, N_Vector* X,
N_Vector z)
{
SUNFunctionBegin(z->sunctx);
sunindextype i, j;
N_Vector* Xsub;
/* create array of nvec N_Vector pointers for reuse within loop */
Xsub = NULL;
Xsub = (N_Vector*)malloc(n... | subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movslq 0x44(%rsp), %rdi
shlq $0x3, %rdi
callq 0x3220
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VScaleAddMulti_ManyVector | SUNErrCode MVAPPEND(N_VScaleAddMulti)(int nvec, sunrealtype* a, N_Vector x,
N_Vector* Y, N_Vector* Z)
{
SUNFunctionBegin(x->sunctx);
sunindextype i, j;
N_Vector *Ysub, *Zsub;
/* create arrays of nvec N_Vector pointers for reuse within loop */
Ysub = Zsub = NULL;
Ysub ... | subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movslq 0x54(%rsp), %rdi
shlq $0x3, %rdi
callq 0x3220
movq %rax, 0x10(%rsp)
movslq 0x5... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VDotProdMulti_ManyVector | SUNErrCode MVAPPEND(N_VDotProdMulti)(int nvec, N_Vector x, N_Vector* Y,
sunrealtype* dotprods)
{
SUNFunctionBegin(x->sunctx);
sunindextype i;
/* call N_VDotProdLocal for each <x,Y[i]> pair */
for (i = 0; i < nvec; i++)
{
dotprods[i] = N_VDotProdLocal(x, Y[i]);
SUN... | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4d14
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rs... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VWrmsNormVectorArray_ManyVector | SUNErrCode MVAPPEND(N_VWrmsNormVectorArray)(int nvec, N_Vector* X, N_Vector* W,
sunrealtype* nrm)
{
SUNFunctionBegin(X[0]->sunctx);
sunindextype i;
SUNAssert(nvec > 0, SUN_ERR_ARG_OUTOFRANGE);
/* call N_VWSqrSumLocal for each (X[i],W[i]) pair */
for (i = 0; i < nv... | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4da0
movq 0x28(%rsp), %rax
movq 0x8(%rsp), ... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
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.