name string | code string | asm string | file string |
|---|---|---|---|
mcpl_buf_is_text | MCPL_LOCAL int mcpl_buf_is_text( mcpl_buffer_t* buf ) {
//We correctly allow ASCII & UTF-8 but not UTF-16 and UTF-32 (by design).
const unsigned char * it = (unsigned char*)buf->buf;
const unsigned char * itE = it + buf->size;
for (; it!=itE; ++it)
if ( ! ( ( *it >=9 && *it<=13 ) || ( *it >=32 && *it<=126 )... | movq 0x8(%rdi), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x7a65
movq (%rdi), %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
leal -0x9(%rdi), %r8d
cmpb $0x5, %r8b
jb 0x7a5d
leal -0x20(%rdi), %r8d
cmpb $0x5f, %r8b
setae %r8b
testb %dil, %dil
setns %dil
testb %r8b, %dil
jne 0x7a66
incq %rsi
cmpq %rsi, %rcx
jne 0x7a37
retq
xo... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcu8str_dealloc | void mcu8str_dealloc( mcu8str* str )
{
char * buf_to_free = ( str->owns_memory
? str->c_str
: NULL );
static char dummy[4] = { 0, 0, 0, 0 };
str->c_str = &dummy[0];
str->size = 0;
str->buflen = 0;
str->owns_memory = 0;
if ( buf_to_free ... | cmpl $0x0, 0x10(%rdi)
je 0x7e38
movq (%rdi), %rax
leaq 0x8470(%rip), %rcx # 0x10289
movq %rcx, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
testq %rax, %rax
je 0x7e4a
movq %rax, %rdi
jmp 0x2070
leaq 0x844a(%rip), %rax # 0x10289
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mctools_strlen | mcu8str_size_t mctools_strlen( const char * c_str, mcu8str_size_t nmax )
{
//safe strlen which guarantees result can fit in an unsigned integer (or
//less, when 0<nmax<UINT_MAX is provided).
if ( nmax == 0 )
nmax = ( UINT_MAX > PTRDIFF_MAX ? PTRDIFF_MAX : UINT_MAX );
if ( nmax > PTRDIFF_MAX )
... | pushq %r15
pushq %r14
pushq %rbx
movl $0xfffffffe, %r15d # imm = 0xFFFFFFFE
leaq 0x1(%r15), %rbx
testq %rsi, %rsi
cmovneq %rsi, %rbx
testq %rbx, %rbx
js 0x7eb1
movq %rdi, %r14
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2230
movq %rax, %rcx
subq %r14, %rax
testq %rcx, %rcx
cmoveq %rbx, %rax
cmpq %r15, %rax
jae 0x7eb6
... | /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mcu8str_append | void mcu8str_append( mcu8str* str, const mcu8str * otherstr )
{
if ( otherstr->size == 0 )
return;
mcu8str_size_t newsize = str->size + otherstr->size;
if ( newsize + 1 > str->buflen )
mcu8str_reserve( str, newsize );
//memcpy ok since we handle the null char afterwards, there will be no
... | movl 0x8(%rsi), %eax
testl %eax, %eax
je 0x7f82
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
leal (%rcx,%rax), %r14d
cmpl 0xc(%rdi), %r14d
jb 0x7f62
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7f83
movl 0x8(%rbx), %ecx
movl 0x8(%r15), %eax
movl %ecx, %edi
addq (%rbx), %rdi
movq (%r1... | /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mcu8str_view_str | mcu8str mcu8str_view_str( const mcu8str * str )
{
mcu8str s;
s.c_str = (char*)str->c_str;//cast away constness, but we will add it again in
//the return type (in c++).
s.size = str->size;
s.buflen = s.size + 1;//limit as much as possible.
s.owns_memory = 0;
return s;... | movq %rdi, %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movl 0x8(%rsi), %ecx
movl %ecx, 0x8(%rdi)
incl %ecx
movl %ecx, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mcu8str_copy | mcu8str mcu8str_copy( const mcu8str* str )
{
if ( str->size == 0 )
return mcu8str_create_empty();
mcu8str newstr = mcu8str_create( str->size );
mcu8str_assign( &newstr, str );
return newstr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
testq %rsi, %rsi
je 0x81ea
movq %rbx, %rdi
callq 0x7ebb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8143
jmp 0x8203
leaq 0x8094(%rip), %rax # 0x10285
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $... | /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mcu8str_create_from_staticbuffer | mcu8str mcu8str_create_from_staticbuffer( char * buf, mcu8str_size_t buflen )
{
if ( buflen==0 || !MCTOOLS_STROKFORUINT(buflen-1) )
mctools_impl_error("static buffer length out of range");
assert(buflen > 0);
mcu8str s;
s.owns_memory = 0;
s.c_str = buf;
s.c_str[0] = '\0';
s.size = 0;... | leaq -0x1(%rdx), %rax
shrq %rax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jae 0x82a6
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rsi, (%rdi)
movb $0x0, (%rsi)
movl %eax, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movq %rdi, %rax
retq
pushq %rax
callq 0x258d
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mcu8str_is_ascii | int mcu8str_is_ascii( const mcu8str* str )
{
const char * it = str->c_str;
const char * itE = it + str->size;
for ( ; it!=itE; ++it )
if ( (unsigned char)(*it) >= 128 )
return 0;
return 1;
} | movl 0x8(%rdi), %ecx
movl $0x1, %eax
testq %rcx, %rcx
je 0x82cc
movq (%rdi), %rdx
xorl %esi, %esi
cmpb $0x0, (%rdx,%rsi)
js 0x82cd
incq %rsi
cmpq %rsi, %rcx
jne 0x82be
retq
xorl %eax, %eax
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mcu8str_contains | int mcu8str_contains( const mcu8str* str, char needle )
{
const char * it = str->c_str;
const char * itE = it + str->size;
for ( ; it!=itE; ++it )
if ( *it == needle )
return 1;
return 0;
} | movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x82eb
movq (%rdi), %rcx
xorl %edx, %edx
cmpb %sil, (%rcx,%rdx)
je 0x82ee
incq %rdx
cmpq %rdx, %rax
jne 0x82dd
xorl %eax, %eax
retq
movl $0x1, %eax
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mctools_fopen | MCTOOLS_FILE_t * mctools_fopen( const mcu8str* rawpath,
const char * mode )
{
mcu8str path = mctools_impl_view_no_winnamespace( rawpath );
//Utf8-encoded paths are used directly on platforms except Windows, where
//only ASCII encoded paths can be used directly. We also r... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1030, %rsp # imm = 0x1030
movq %rsi, %rbx
movq (%rdi), %r14
movq %r14, (%rsp)
movl 0x8(%rdi), %r15d
movl %r15d, 0x8(%rsp)
leal 0x1(%r15), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x8313
testl %eax, %eax
je 0x83e6
addq $0x4, %r14
movq %r14, (%rsp)
addl $-0x... | /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mctools_fileextension | mcu8str mctools_fileextension( const mcu8str* path )
{
const char * it = mctools_fileextension_view( path );
return mcu8str_create_from_cstr( it );
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x921b
xorl %ecx, %ecx
movzbl (%rax), %edx
cmpl $0x2e, %edx
je 0x90d9
testl %edx, %edx
jne 0x90dc
jmp 0x90e1
movq %rax, %rcx
incq %rax
jmp 0x90cb
leaq 0x1(%rcx), %rsi
testq %rcx, %rcx
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x8055
movq %rbx, %rax
popq %rbx
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mctools_fileextension_view | const char* mctools_fileextension_view( const mcu8str* path )
{
const char * it = mctools_basename_view( path );
const char * itLastDot = NULL;
while ( 1 ) {
if ( *it == 0 )
break;//end of string reached
if ( *it == '.' )
itLastDot = it;
++it;
}
if ( itLastDot )
... | pushq %rax
callq 0x921b
xorl %edx, %edx
movzbl (%rax), %ecx
cmpl $0x2e, %ecx
je 0x910f
testl %ecx, %ecx
jne 0x9112
jmp 0x9117
movq %rax, %rdx
incq %rax
jmp 0x9101
leaq 0x1(%rdx), %rcx
testq %rdx, %rdx
cmoveq %rax, %rcx
movq %rcx, %rax
popq %rcx
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mctools_basename | mcu8str mctools_basename( const mcu8str* path )
{
const char * itB = path->c_str;
const char * itE = path->c_str + path->size;
if ( mctools_impl_has_winnamespace( path ) )
itB += 4;//skip '\\?\'
if ( mctools_drive_letter( path ) )
itB += 2;//skip drive letter
if ( itB == itE )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movl 0x8(%rsi), %r12d
leaq (%r15,%r12), %r13
movq %rsi, %rdi
callq 0x8313
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq (%r15,%rcx,4), %rbp
movq %r14, %rdi
callq 0x8abf
xorl %ecx, %ecx
testb ... | /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
mctools_absolute_path | mcu8str mctools_absolute_path( const mcu8str* pathraw )
{
mcu8str path = mctools_impl_view_no_winnamespace(pathraw);
mcu8str res = mcu8str_create_empty();
if ( path.size == 0 )
return res;
#ifdef MC_IS_WINDOWS
{
mcwinstr wpath = mc_path2wpath( &path );
res = mc_winstr_expand_to_fullp... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, (%rsp)
movl 0x8(%rsi), %r14d
movl %r14d, 0x8(%rsp)
leal 0x1(%r14), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x8313
testl %eax, %eax
je 0x9465
addq $0x4, %r15
movq %r15, (%rsp)
addl $-0x4, %r14d
mo... | /mctools[P]mcpl/mcpl_core/src/mcpl_fileutils.c |
main | int
main()
{
using namespace boost::ut;
"test_bqp_clean"_test = [] {
auto ctx = baryonyx::make_context(4);
{
const char* str_pb = "minimize\n"
"-5a + [ 2a * b + 6c * d ] /2 + 10b\n"
"Subject to:\n"
... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x20b(%rip), %rax # 0x9b68
leaq 0x43f881(%rip), %r14 # 0x4491e5
leaq 0x43f8d7(%rip), %rsi # 0x449242
leaq 0x18(%rsp), %rbx
movq %rax, 0xb0(%rsp)
movq %r14, 0xb8(%rsp)
movl $0x30, 0xc0(%rsp)
pushq $0xe
popq %rdx
movq %rbx, %rdi
callq 0xb891
movq 0xc0(%rsp), %rax
mo... | /quesnel[P]baryonyx/lib/test/preprocess.cpp |
void boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>::on<bool>(boost::ext::ut::v1_1_8::events::assertion_fail<bool>)::'lambda'(std::basic_string_view<char, std::char_traits<char>>)::operator()(std::basic_string_view<char, std::char_traits<char>>) const | auto on(events::assertion_fail<TExpr> assertion) -> void {
constexpr auto short_name = [](std::string_view name) {
return name.rfind('/') != std::string_view::npos
? name.substr(name.rfind('/') + 1)
: name;
};
printer_ << "\n " << short_name(assertion.loc... | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
pushq $0x2f
popq %rsi
pushq $-0x1
popq %rdx
callq 0xc2d4
cmpq $-0x1, %rax
je 0xce62
leaq 0x8(%rsp), %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc2d4
leaq 0x1(%rax), %rsi
movq %... | /quesnel[P]baryonyx/external/ut/include/boost/ut.hpp |
boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>::on(boost::ext::ut::v1_1_8::events::exception) | auto on(events::exception exception) -> void {
printer_ << "\n " << printer_.colors().fail
<< "Unexpected exception with message:\n"
<< exception.what() << printer_.colors().none;
++asserts_.fail;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
addq $0x70, %rdi
leaq 0x43be98(%rip), %rsi # 0x449420
callq 0x9350
leaq 0x50(%rbx), %rsi
movq %r15, %rdi
callq 0xc202
leaq 0x40(%rax), %r13
leaq 0x43bf08(%rip), %rsi # 0x4494ac
movq %rax, %r12
movq %r13, %... | /quesnel[P]baryonyx/external/ut/include/boost/ut.hpp |
boost::ext::ut::v1_1_8::runner<boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>, 16>::run(boost::ext::ut::v1_1_8::run_cfg) | [[nodiscard]] auto run(run_cfg rc = {}) -> bool {
run_ = true;
for (const auto& suite : suites_) {
suite();
}
suites_.clear();
if (rc.report_errors) {
reporter_.on(events::summary{});
}
return fails_ > 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, 0x208(%rdi)
movl %esi, %ebp
movq %rdi, %rbx
movq 0x1e8(%rdi), %r14
movq 0x1f0(%rdi), %r15
cmpq %r15, %r14
je 0xde1d
callq *(%r14)
addq $0x8, %r14
jmp 0xde0f
movq 0x1e8(%rbx), %rax
cmpq %rax, 0x1f0(%rbx)
je 0xde34
movq %rax, 0x1f0(%rbx)
testb $0x1, %bpl
j... | /quesnel[P]baryonyx/external/ut/include/boost/ut.hpp |
boost::ext::ut::v1_1_8::reporter<boost::ext::ut::v1_1_8::printer>::on(boost::ext::ut::v1_1_8::events::summary) | auto on(events::summary) -> void {
if (static auto once = true; once) {
once = false;
if (tests_.fail or asserts_.fail) {
printer_
<< "\n========================================================"
"=======================\n"
<< "tests: " << (t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpb $0x1, 0x61d503(%rip) # 0x62b370
jne 0xe0ba
movb $0x0, 0x61d4f6(%rip) # 0x62b370
movq %rdi, %rbx
movq 0x20(%rdi), %rax
orq 0x8(%rdi), %rax
jne 0xdf40
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %rsi
movq 0x61d11e(%rip), %rdi # 0x... | /quesnel[P]baryonyx/external/ut/include/boost/ut.hpp |
baryonyx::optimize(std::unique_ptr<baryonyx::context, void (*)(baryonyx::context*)> const&, baryonyx::raw_problem const&) | result
optimize(const baryonyx::context_ptr& ctx, const raw_problem& rawpb)
{
if (ctx) {
if ((ctx->parameters.mode & solver_parameters::mode_type::branch) ==
solver_parameters::mode_type::branch)
return (ctx->parameters.preprocessor ==
solver_parameters::preproces... | pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq 0x8(%rsi), %r14
movq %rdi, %rbx
testq %r14, %r14
je 0xe39d
movl 0xdc(%r14), %eax
testb $0x4, %al
jne 0xe3d2
testb $0x2, %al
jne 0xe3ff
movl 0xe0(%r14), %ecx
testb $0x1, %al
jne 0xe44e
cmpl $0x1, %ecx
jne 0xe492
leaq 0x8(%rsp), %r15
movq %r... | /quesnel[P]baryonyx/lib/src/lpcore.cpp |
baryonyx::context::context(int) | context(int verbose_level = 6)
: log_priority(convert_verbose_level(verbose_level))
{} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xf080
leaq 0x108(%r14), %rax
movq %rax, 0xf8(%r14)
andq $0x0, 0x100(%r14)
movb $0x0, 0x108(%r14)
cmpl $0x7, %ebx
pushq $0x7
popq %rax
cmovbl %ebx, %eax
xorl %ecx, %ecx
testl %ebx, %ebx
vxorps %xmm0, %xmm0, %xmm0
cmovnsl %eax, %ecx
vmovups %zmm0, 0x... | /quesnel[P]baryonyx/lib/src/private.hpp |
fmt::v7::detail::ansi_color_escape<char>::ansi_color_escape(fmt::v7::detail::color_type, char const*) | FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
const char* esc) FMT_NOEXCEPT {
// If we have a terminal color, we need to output another escape code
// sequence.
if (!text_color.is_rgb) {
bool is_background = esc == detail::data::background_color;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
shrq $0x20, %r14
movq %rsi, %r15
movq %rdi, %rbx
testb $0x1, %r15b
je 0xf962
xorl %eax, %eax
cmpq $0x7, %rax
je 0xf994
movb (%rdx,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0xf951
leaq 0x43ac7a(%rip), %rcx # 0x44a5e3
movzbl %r14b, %esi
movw $... | /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_nonfinite<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, bool, fmt::v7::basic_f... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x439dc1(%rip), %rcx # 0x44a828
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::dragonbox::floor_log2_pow10(int) | inline int floor_log2_pow10(int e) FMT_NOEXCEPT {
FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
const uint64_t log2_10_integer_part = 3;
const uint64_t log2_10_fractional_digits = 0x5269e12f346e2bf9;
const int shift_amount = 19;
return (e * static_cast<int>(
(log2_10_integer_par... | leal 0x4d1(%rdi), %eax
cmpl $0x9a3, %eax # imm = 0x9A3
jae 0x10c62
imull $0x1a934f, %edi, %eax # imm = 0x1A934F
sarl $0x13, %eax
retq
pushq %rax
leaq 0x439352(%rip), %rdi # 0x449fbc
leaq 0x4393b6(%rip), %rdx # 0x44a027
movl $0x6c3, %esi # imm = 0x6C3
callq 0xf8eb
| /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
unsigned int fmt::v7::detail::dragonbox::small_division_by_pow10<1>(unsigned int) | uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT {
static constexpr struct {
uint32_t magic_number;
int shift_amount;
uint32_t divisor_times_10;
} infos[] = {{0xcccd, 19, 100}, {0xa3d8, 22, 1000}};
constexpr auto info = infos[N - 1];
FMT_ASSERT(n <= info.divisor_times_10, "n is too large");... | cmpl $0x65, %edi
jae 0x10d1d
imull $0xcccd, %edi, %eax # imm = 0xCCCD
shrl $0x13, %eax
retq
pushq %rax
leaq 0x439297(%rip), %rdi # 0x449fbc
leaq 0x439320(%rip), %rdx # 0x44a04c
movl $0x713, %esi # imm = 0x713
callq 0xf8eb
| /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, long double, 0>(fmt::v7::detail::buffer_appender<char>, long double, fmt::v7::basic_format_specs<char>, fmt::v7::detail::locale_ref) | OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
locale_ref loc = {}) {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (std::signbit(value)) { // value < 0 is false for NaN so ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
fldt 0x2b0(%rsp)
fld %st(0)
fstpt 0x24(%rsp)
fstpt 0x40(%rsp)
leaq 0x30(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
movswq 0x48(%rsp), %r13
movq %rsi, (%r12)
leaq 0x60(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_bytes<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_string_view... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x437306(%rip), %rcx # 0x44a828
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::bigint::remove_leading_zeros() | void remove_leading_zeros() {
int num_bigits = static_cast<int>(bigits_.size()) - 1;
while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
bigits_.resize(to_unsigned(num_bigits + 1));
} | pushq %rbp
pushq %r14
pushq %rbx
movl 0x10(%rdi), %ebp
movq %rdi, %rbx
movl %ebp, %r14d
cmpl $0x2, %ebp
jl 0x1454b
leal -0x1(%r14), %ebp
movl %ebp, %edi
callq 0x10ac5
movq 0x8(%rbx), %rcx
movl %eax, %eax
cmpl $0x0, (%rcx,%rax,4)
je 0x1452c
movl %r14d, %edi
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
popq %rbx
popq %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v7::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&) | 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);
std::uninitialized_copy(other.store_, other.store_ + size,
... | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rcx
movq %rsi, %rax
addq $0x20, %rsi
movq %rdi, %rbx
cmpq %rsi, %rdx
je 0x145a4
movq %rdx, 0x8(%rbx)
movq %rcx, 0x18(%rbx)
movq %rsi, 0x8(%rax)
andq $0x0, 0x18(%rax)
jmp 0x145c2
leaq 0x20(%rbx), %rdi
movq %rdi, 0x8(%rbx)
movq ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::bigint::align(fmt::v7::detail::bigint const&) | 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, --j)
bigits_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0xa8(%rdi), %r14d
subl 0xa8(%rsi), %r14d
jle 0x146de
movl 0x10(%rdi), %r15d
movq %rdi, %rbx
leal (%r14,%r15), %edi
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
callq 0x14336
movq 0x8(%rbx), %rdi
leal -0x1(%r15,%r14), %ecx
movl %r15d, %eax
decl %eax
movslq %ecx, %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::subtract_aligned(fmt::v7::detail::bigint const&) | 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.bigits_[j], borrow)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xa8(%rsi), %eax
cmpl 0xa8(%rdi), %eax
jl 0x14791
movq %rsi, %r14
movq %rdi, %rbx
callq 0x140cd
testl %eax, %eax
js 0x147a9
leaq 0x4(%rsp), %rax
xorl %r15d, %r15d
andl $0x0, (%rax)
movl 0xa8(%r14), %r13d
movq 0x10(%r14), %rbp
subl 0xa8(%r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::bigint::multiply(unsigned int) | void multiply(uint32_t value) {
const double_bigit wide_value = value;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
double_bigit result = bigits_[i] * wide_value + carry;
bigits_[i] = static_cast<bigit>(result);
carry = static_cast<bigit>(result >> bigit_bits);
... | pushq %rax
andl $0x0, 0x4(%rsp)
movl %esi, %eax
xorl %edx, %edx
xorl %r8d, %r8d
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rsi
cmpq %r8, %rsi
je 0x148a6
movl (%rcx,%r8,4), %r9d
movl %edx, %edx
imulq %rax, %r9
addq %r9, %rdx
movl %edx, (%rcx,%r8,4)
shrq $0x20, %rdx
incq %r8
movl %edx, 0x4(%rsp)
jmp 0x14883
testl %edx, %edx
... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, ... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x435e9e(%rip), %rcx # 0x44ab09
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, ... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x435d99(%rip), %rcx # 0x44ab09
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_ptr<char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long, fmt::v7::basic_format_specs<char> const*) | OutputIt write_ptr(OutputIt out, UIntPtr value,
const basic_format_specs<Char>* specs) {
int num_digits = count_digits<4>(value);
auto size = to_unsigned(num_digits) + size_t(2);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
auto write = [=](iterator it) {
*it++ = static... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rbx
movq %rsi, %r15
callq 0x14f50
movl %eax, %edi
movl %eax, %ebp
callq 0x10ac5
movl %eax, %edx
addq $0x2, %rdx
movq %r15, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
testq %rbx, %rbx
je 0x14f2d
leaq 0x8(%rsp), %rcx
movq %r14, ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<4u, char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
callq 0xfc1a
movzbl %r15b, %ecx
testq %rax, %rax
je 0x15083
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x150b6
jmp 0x150a... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::id_adapter<fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&, char>&>(char const*, char const*, fmt::v7::detail::id_adapter<fmt::v7::detail::format_h... | FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c == '}' || c == ':') {
handler();
return begin;
}
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0'... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x155e1
movzbl (%rdi), %eax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x7d, %eax
je 0x154f6
cmpl $0x3a, %eax
jne 0x1550b
movq %rbx, %rdi
callq 0x158fe
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leal -0x30(%rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::basic_string_view<char>::compare(fmt::v7::basic_string_view<char>) const | int compare(basic_string_view other) const {
size_t str_size = size_ < other.size_ ? size_ : other.size_;
int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
if (result == 0)
result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rdx, %rbx
movq 0x8(%r14), %rdx
movq (%rdi), %rdi
cmpq %rbx, %rdx
cmovaeq %rbx, %rdx
callq 0xcf1a
testl %eax, %eax
jne 0x15aef
movq 0x8(%r14), %rcx
cmpq %rbx, %rcx
sbbl %edx, %edx
xorl %eax, %eax
orl $0x1, %edx
cmpq %rbx, %rcx
cmovnel %edx, %eax
addq $0x8, %rsp
popq... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()<float, 0>(float) | iterator operator()(T value) {
auto specs = specs_ ? *specs_ : format_specs();
if (const_check(is_supported_floating_point(value)))
out_ = detail::write(out_, value, specs, locale_);
else
FMT_ASSERT(false, "unsupported float argument type");
return out_;
} | pushq %rbx
movq 0x10(%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x16890
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x168a4
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x19720
movq %rax, (%rbx)
popq %... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()<double, 0>(double) | iterator operator()(T value) {
auto specs = specs_ ? *specs_ : format_specs();
if (const_check(is_supported_floating_point(value)))
out_ = detail::write(out_, value, specs, locale_);
else
FMT_ASSERT(false, "unsupported float argument type");
return out_;
} | pushq %rbx
movq 0x10(%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x168cc
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x168e0
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x1a711
movq %rax, (%rbx)
popq %... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct() | void on_oct() {
int num_digits = count_digits<3>(abs_value);
if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
// Octal prefix '0' is counted as a digit, so only add it if precision
// is not greater than the number of digits.
prefix[prefix_size++] = '0';
}
out = writ... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %edi
callq 0x17517
movq 0x10(%rbx), %r8
cmpb $0x0, 0x9(%r8)
jns 0x16c85
cmpl %eax, 0x4(%r8)
jg 0x16c85
cmpl $0x0, 0x18(%rbx)
je 0x16c85
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movq (%rbx), %rdi
movl 0x20(%r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_num() | void on_num() {
std::string groups = grouping<Char>(locale);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<Char>(locale);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits, n = num_digits;
std::string::const_iterator group = groups.cbe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x177bf
cmpq $0x0, 0x8(%r14)
je 0x16d26
movq 0x8(%rbx), %rdi
callq 0x1781f
movl %eax, %ebp
testb %al, %al
je 0x16d33
movl 0x18(%rbx), %edi
callq 0x... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16f52
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16f52
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<4u, char, unsigned int>(char*, unsigned int, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %edx, %r8
testl %ecx, %ecx
leaq 0x432f70(%rip), %r9 # 0x44a245
leaq 0x433fb4(%rip), %rdx # 0x44b290
leaq -0x1(%rdi,%r8), %rcx
leaq (%rdi,%r8), %rax
cmovneq %r9, %rdx
movl %esi, %edi
movl %esi, %r8d
andl $0xf, %r8d
shrl $0x4, %edi
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx)
decq %rcx
cmpl $0xf, %esi
movl %edi,... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16f52
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'la... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43374b(%rip), %rcx # 0x44ab09
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, char, fmt::v7::detail::buffer_appender<char>, unsigned int>(fmt::v7::detail::buffer_appender<char>, unsigned int, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
callq 0xfc1a
movzbl %r15b, %ecx
testq %rax, %rax
je 0x174bc
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x174ef
jmp 0x17... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<3u, char, fmt::v7::detail::buffer_appender<char>, unsigned int>(fmt::v7::detail::buffer_appender<char>, unsigned int, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
callq 0xfc1a
movzbl %r15b, %ecx
testq %rax, %rax
je 0x176ce
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x17704
jmp 0x17... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basi... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16f52
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'l... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x4327d9(%rip), %rcx # 0x44ab09
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x431e5d(%rip), %rcx # 0x44ab09
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<4u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %ecx, %r9
leaq 0x43143e(%rip), %r10 # 0x44a245
leaq 0x432482(%rip), %rcx # 0x44b290
testl %r8d, %r8d
leaq (%rdi,%r9), %rax
leaq -0x1(%rdi,%r9), %rdi
cmovneq %r10, %rcx
pushq $0xf
popq %r8
movq %rdx, %r9
movl %esi, %r10d
andl $0xf, %r10d
movq %rdx, %r11
shldq $0x3c, %rsi, %r11
shrq $0x4, %r9
movb (%rcx,%r10... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16f52
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, char, fmt::v7::detail::buffer_appender<char>, unsigned __int128>(fmt::v7::detail::buffer_appender<char>, unsigned __int128, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl %ecx, %edi
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
callq 0xfc1a
movzbl %r12b, %r8d
testq %rax, %rax
je 0x19035
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<1u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
leaq -0x1(%rdi,%rcx), %rcx
pushq $0x1
popq %rdi
movq %rdx, %r8
movl %esi, %r9d
movq %rdx, %r10
shldq $0x3f, %rsi, %r10
shrq %r8
andb $0x1, %r9b
orb $0x30, %r9b
movb %r9b, (%rcx)
decq %rcx
cmpq %rsi, %rdi
movl $0x0, %esi
sbbq %rdx, %rsi
movq %r10, %rsi
movq %r8, %rdx
jb 0x19082
r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16f52
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_oct()... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x431986(%rip), %rcx # 0x44ab09
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<3u, char, fmt::v7::detail::buffer_appender<char>, unsigned __int128>(fmt::v7::detail::buffer_appender<char>, unsigned __int128, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl %ecx, %edi
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
callq 0x10ac5
movl %eax, %esi
movq %rbx, %rdi
callq 0xfc1a
movzbl %r12b, %r8d
testq %rax, %rax
je 0x19290
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<3u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
leaq -0x1(%rdi,%rcx), %rcx
pushq $0x7
popq %rdi
movq %rdx, %r8
movl %esi, %r9d
movq %rdx, %r10
shldq $0x3d, %rsi, %r10
shrq $0x3, %r8
andb $0x7, %r9b
orb $0x30, %r9b
movb %r9b, (%rcx)
decq %rcx
cmpq %rsi, %rdi
movl $0x0, %esi
sbbq %rdx, %rsi
movq %r10, %rsi
movq %r8, %rdx
jb 0x1... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_spec... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x4312e8(%rip), %rcx # 0x44a828
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_char<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x10ac5
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x431171(%rip), %rcx # 0x44a828
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, float, 0>(fmt::v7::detail::buffer_appender<char>, float, fmt::v7::basic_format_specs<char>, fmt::v7::detail::locale_ref) | OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
locale_ref loc = {}) {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (std::signbit(value)) { // value < 0 is false for NaN so ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
leaq 0x10(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
vmovaps %xmm0, 0x20(%rsp)
movq %rsi, (%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(%r12)
callq 0x12967
vmovdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::snprintf_float<double>(double, int, fmt::v7::detail::float_specs, fmt::v7::detail::buffer<char>&) | int snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
static_assert(!std::is_same<T, float>::value, "");
// Subtract 1 to account... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdx), %rax
vmovsd %xmm0, 0x10(%rsp)
cmpq 0x10(%rdx), %rax
jbe 0x19c53
shrq $0x20, %rsi
movq %rdx, %rbx
leal -0x1(%rdi), %eax
testl %edi, %edi
pushq $0x5
popq %rbp
cmovnsl %eax, %ebp
cmpb $0x2, %sil
movb $0x25, 0x1(%rsp)
cmovae... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
int fmt::v7::detail::format_float<double>(double, int, fmt::v7::detail::float_specs, fmt::v7::detail::buffer<char>&) | int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
static_assert(!std::is_same<T, float>::value, "");
FMT_ASSERT(value >= 0, "value is negative");
const bool fixed = specs.format == float_format::fixed;
if (value <= 0) { // <= instead of == to silence a warning.
if (precision... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jb 0x1a08d
movabsq $0xff00000000, %rbx # imm = 0xFF00000000
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rdx, %rbp
movl %edi, %r15d
andq %rsi, %rbx
cmpq %rax, %rbx
sete %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
void fmt::v7::detail::fallback_format<double>(double, int, bool, fmt::v7::detail::buffer<char>&, int&) | void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
int& exp10) {
bigint numerator; // 2 * R in (FPP)^2.
bigint denominator; // 2 * S in (FPP)^2.
// lower and upper are differences between value and corresponding boundaries.
bigint lower; // (M^-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
leaq 0xf8(%rsp), %rax
movq %rcx, 0x18(%rsp)
leaq 0x60e8ae(%rip), %rcx # 0x6289c0
movq %rdx, 0x8(%rsp)
movl %edi, %r12d
andq $0x0, 0x10(%rax)
movq %rcx, (%rax)
pushq $0x20
popq %rdx
leaq (%rax,%rdx), %rdi
leaq... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, double, 0>(fmt::v7::detail::buffer_appender<char>, double, fmt::v7::basic_format_specs<char>, fmt::v7::detail::locale_ref) | OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
locale_ref loc = {}) {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (std::signbit(value)) { // value < 0 is false for NaN so ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
leaq 0x10(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
vmovaps %xmm0, 0x20(%rsp)
movq %rsi, (%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(%r12)
callq 0x12967
vmovdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write(char const*) | void write(const Char* value) {
if (!value) {
FMT_THROW(format_error("string pointer is null"));
} else {
auto length = std::char_traits<char_type>::length(value);
basic_string_view<char_type> sv(value, length);
specs_ ? write(sv, *specs_) : write(sv);
}
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1a9f1
movq %rdi, %r14
movq %rsi, %rdi
movq %rsi, %rbx
callq 0x9210
movq 0x10(%r14), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
testq %rcx, %rcx
je 0x1a9e9
popq %rbx
popq %r14
jmp 0x19462
popq %rbx
popq %r14
jmp 0x1aa66
pushq $0x10
popq %rd... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::handle_cstring_type_spec<char, fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::cstring_spec_handler>(char, fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::cstring_s... | FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
if (spec == 0 || spec == 's')
handler.on_string();
else if (spec == 'p')
handler.on_pointer();
else
handler.on_error("invalid type specifier");
} | cmpl $0x73, %edi
je 0x1aa42
cmpl $0x70, %edi
je 0x1aa4a
testl %edi, %edi
jne 0x1aa52
movq %rsi, %rdi
jmp 0x1aa90
movq %rsi, %rdi
jmp 0x1aaa0
pushq %rax
leaq 0x42f641(%rip), %rax # 0x44a09b
movq %rsi, %rdi
movq %rax, %rsi
callq 0xfaa2
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
baryonyx::itm::manual_optimize(baryonyx::context const&, baryonyx::problem const&) | result
manual_optimize(const baryonyx::context& ctx, const baryonyx::problem& pb)
{
baryonyx::notice(ctx, "- auto-tune parameters (manual) starts\n");
return ::optimize(ctx, pb);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, %rbx
leaq 0x43036f(%rip), %rsi # 0x44b440
movq %rbx, %rdi
callq 0x1b39a
vmovsd 0x8(%rbx), %xmm0
vmovsd 0x10(%rbx), %xmm1
vmovsd 0x18(%rbx), %xmm2
vmovsd 0x20(%rbx), ... | /quesnel[P]baryonyx/lib/src/manual-optimizer.cpp |
void fmt::v7::print<char const*, double, double, double, double, double, 0>(_IO_FILE*, fmt::v7::text_style const&, char const* const&, double const&, double const&, double const&, double const&, double const&) | void print(std::FILE* f, const text_style& ts, const S& format_str,
const Args&... args) {
vprint(f, ts, format_str,
fmt::make_args_checked<Args...>(format_str, args...));
} | subq $0x58, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %r10
movq (%rcx), %rcx
movq (%r8), %r11
movq (%r9), %r9
movq %rsp, %r8
movq (%r10), %r10
movq (%rax), %rax
movq %rcx, (%r8)
movl $0xaaaaa, %ecx # imm = 0xAAAAA
movq %r11, 0x10(%r8)
movq %r9, 0x20(%r8)
movq %r10, 0x30(%r8)
movq %rax, 0x40(%r8)
callq 0xf1e7... | /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
baryonyx::itm::nlopt_optimize(baryonyx::context const&, baryonyx::problem const&) | result
nlopt_optimize(const context& ctx, const problem& pb)
{
notice(ctx, "- auto-tune parameters (nlopt) starts\n");
#ifdef BARYONYX_HAVE_NLOPT
return ::optimize(ctx, pb);
#else
error(ctx,
" Baryonyx does not have nlopt. Toggle to manual parameters "
"optimization.\n");
return m... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0x42fa35(%rip), %rsi # 0x44b700
movq %rdi, %r15
movq %r14, %rdi
movq %rdx, %rbx
callq 0x1b39a
leaq 0x42fa47(%rip), %rsi # 0x44b727
movq %r14, %rdi
callq 0x1bcff
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b0b0
movq %r15, %rax
popq %rbx
popq %r14
p... | /quesnel[P]baryonyx/lib/src/nlopt-optimizer.cpp |
read_real(std::basic_string_view<char, std::char_traits<char>>) | std::optional<double>
read_real(const std::string_view buf) noexcept
{
if (buf.size() >= 3 && are_equal(buf, "inf"))
return std::numeric_limits<double>::infinity();
constexpr std::size_t max_digits = 320;
if (buf.size() > max_digits)
return std::nullopt;
char buffer[max_digits] = { '\0... | pushq %r14
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x3, %rdi
jb 0x1bd5e
leaq 0x42e273(%rip), %rcx # 0x449fb0
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d7c3
testb %al, %al
je 0x1bda0
vmovsd 0x42dc19(%rip), %xmm0 # 0x449970
movb $0x1, %al
jmp 0x... | /quesnel[P]baryonyx/lib/src/parser.cpp |
read_real(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | std::optional<real_token>
read_real(const std::string_view buf_1, const std::string_view buf_2) noexcept
{
std::optional<double> value_opt;
if (buf_1 == "-") {
value_opt = read_real(buf_2);
if (!value_opt)
return real_token(-1.0, 1);
else
return real_token(-1.0 *... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %r8, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x42faaf(%rip), %rcx # 0x44b904
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %r12, %rsi
callq 0x1d81c
testb %al, %al
je 0x1be85
movq %r15, %rdi
movq %r14, %rsi
callq 0x1bd20
testb $... | /quesnel[P]baryonyx/lib/src/parser.cpp |
read_name(std::basic_string_view<char, std::char_traits<char>>) | std::optional<std::string_view>
read_name(const std::string_view buf) noexcept
{
return std::find_if_not(std::begin(buf), std::end(buf), is_char_name) ==
std::end(buf)
? std::make_optional(buf)
: std::nullopt;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq (%rdx,%rsi), %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x192e(%rip), %rdx # 0x1d850
movq %r14, %rdi
movq %r12, %rsi
callq 0x1e27b
cmpq %r12, %rax
je 0x1bf36
xorl %eax, %eax
jmp 0x1bf3f
movb $0x1, %al
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
... | /quesnel[P]baryonyx/lib/src/parser.cpp |
read_bound(std::array<std::basic_string_view<char, std::char_traits<char>>, 10ul> const&) | std::optional<bound_token>
read_bound(const stream_buffer::string_view_array& tokens) noexcept
{
if (starts_with_number(tokens[0])) {
auto left_opt =
read_left_bound_token(tokens[0], tokens[1], tokens[2], tokens[3]);
if (!left_opt)
return std::nullopt;
int read = left_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %rsi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1dba1
testb %al, %al
je 0x1cb9f
vmovupd 0x20(%r14), %ymm0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
leaq 0x28(%rsp), %r15
movq %r... | /quesnel[P]baryonyx/lib/src/parser.cpp |
read_objective_type(std::basic_string_view<char, std::char_traits<char>>) | std::optional<baryonyx::objective_function_type>
read_objective_type(const std::string_view token) noexcept
{
if (are_equal(token, "maximize") || are_equal(token, "maximum") ||
are_equal(token, "max"))
return baryonyx::objective_function_type::maximize;
if (are_equal(token, "minimize") || are_e... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x100000000, %r12 # imm = 0x100000000
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x42ec48(%rip), %rcx # 0x44b914
pushq $0x8
popq %rdx
callq 0x1d7c3
testb %al, %al
jne 0x1cd0a
leaq 0x42ec3e(%rip), %rcx # 0x44b91d
pushq $0x7
popq %rdx
movq %r14, %rdi
mo... | /quesnel[P]baryonyx/lib/src/parser.cpp |
is_char_name(int) | constexpr bool
is_char_name(const int c) noexcept
{
if ((c >= static_cast<int>('a') && c <= static_cast<int>('z')) ||
(c >= static_cast<int>('A') && c <= static_cast<int>('Z')) ||
(c >= static_cast<int>('0') && c <= static_cast<int>('9')))
return true;
switch (c) {
case '!':
cas... | leal -0x30(%rdi), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
jb 0x1d87f
movl %edi, %ecx
andl $-0x21, %ecx
addl $-0x41, %ecx
cmpl $0x1a, %ecx
jb 0x1d87f
leal -0x21(%rdi), %ecx
cmpl $0x3e, %ecx
ja 0x1d880
movabsq $0x40000000c40029bf, %rdx # imm = 0x40000000C40029BF
btq %rcx, %rdx
jae 0x1d880
retq
addl $-0x7b, %edi
cmpl $0x3, %e... | /quesnel[P]baryonyx/lib/src/parser.cpp |
stream_buffer::pop_front(int) | void pop_front(int size)
{
bx_expects(size >= 1 && size < stream_buffer_size);
auto tmp = buffer_ptr[0];
buffer_ptr[0] = buffer_ptr[(size + 0) % stream_buffer_size];
buffer_ptr[1] = buffer_ptr[(size + 1) % stream_buffer_size];
buffer_ptr[2] = buffer_ptr[(size + 2) % stream_... | subq $0x18, %rsp
leal -0x1(%rsi), %eax
cmpl $0x9, %eax
jae 0x1da7d
vmovups (%rdi), %xmm0
movl %esi, %eax
shlq $0x4, %rax
leal 0x1(%rsi), %ecx
cmpl $0x9, %esi
vmovaps %xmm0, (%rsp)
vmovups (%rdi,%rax), %xmm0
leal -0x9(%rsi), %eax
cmovael %eax, %ecx
leal -0x8(%rsi), %eax
shlq $0x4, %rcx
cmpl $0x8, %esi
vmovups %xmm0, (%r... | /quesnel[P]baryonyx/lib/src/parser.cpp |
problem_parser::get_or_assign_variable(std::basic_string_view<char, std::char_traits<char>>) | int get_or_assign_variable(const std::string_view value)
{
if (auto it = m_cache_variable.find(value);
it != m_cache_variable.end())
return it->second;
if (m_cache_variable.size() > baryonyx::to_unsigned(INT_MAX))
return -1;
auto size = static_cast<int>(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x18(%rsp), %rax
leaq 0xc8(%rdi), %r15
movq %rdi, %rbx
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1e66c
testq %rax, %rax
je 0x1dad7
movl 0x18(%rax), %eax
jmp 0x1db5d
movq 0xe0(%rbx), %rax
cmpq $0x7fffffff, %rax #... | /quesnel[P]baryonyx/lib/src/parser.cpp |
problem_parser::append_to_objective(function_element_token const&) | [[nodiscard]] bool append_to_objective(const function_element_token& elem)
{
if (elem.name.empty()) {
m_problem.objective.value += elem.factor;
return true;
} else {
auto id = get_or_assign_variable(elem.name);
if (id == -1)
return fals... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
movq %rdi, %r14
testq %rsi, %rsi
je 0x1dcaf
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x1da9e
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
setne %bpl
je 0x1dcd8
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movl %eax, %edx
callq 0x1ecce
cmp... | /quesnel[P]baryonyx/lib/src/parser.cpp |
problem_parser::set_bound_variable(bound_token) | [[nodiscard]] bool set_bound_variable(bound_token bound)
{
auto id = get_variable(bound.name);
if (id < 0)
return false;
// We only use a binary/integer solver.
// m_problem.vars.values[id].min = bound.min;
// m_problem.vars.values[id].max = bound.max;
m... | pushq %rbx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rdi, %rbx
callq 0x1ef0a
testl %eax, %eax
js 0x1dfb1
leaq 0x10(%rsp), %rcx
movq 0xa8(%rbx), %rsi
movl %eax, %edx
imulq $0xc, %rdx, %rdx
vmovupd (%rcx), %xmm0
vcmpeqpd 0x42d7f2(%rip), %xmm0, %k1 # 0x44b790
vcvttpd2dq %xmm0, %xmm0
vmovdqa32 0x42d7f4(%rip), %xmm0... | /quesnel[P]baryonyx/lib/src/parser.cpp |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [3], double const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [3], double const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdx), %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %rax, (%r14)
callq 0xf3b2
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x25da5
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [6], double const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [6], double const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdx), %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %rax, (%r14)
callq 0xf3b2
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x25da5
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
void write_constraint<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem, baryonyx::constraint>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&, baryonyx::constraint const&, char const*) | void
write_constraint(FormatContext& ctx,
const Problem& p,
const Constraint& cst,
const char* separator)
{
if (!cst.label.empty())
fmt::format_to(ctx.out(), "{}: ", cst.label);
write_function_element(ctx, p, cst.elements);
fmt::format_to(ctx.out(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdx)
je 0x25fea
movq (%r14), %rdi
leaq 0x4266d0(%rip), %rsi # 0x44c6b2
movq %rbx, %rdx
callq 0x25cec
leaq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2601e
movq (%r14), %rd... | /quesnel[P]baryonyx/lib/src/problem.hpp |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [10], std::basic_string_view<char, std::char_traits<char>> const&, int const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [10], std::basic_string_view<char, std::char_trai... | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
movl (%rcx), %ecx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, (%r14)
movq %rax, 0x8(%r14)
movq %rcx, 0x10(%r14)
callq 0xf3b2
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0x1d
popq %rdx
movq %rbx, %rdi
mov... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, std::vector<baryonyx::objective_function_element, std::allocator<baryonyx::objective_function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx:... | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %rbp
vxorpd %xmm1, %xmm1, %xmm1
leaq 0x42624e(%rip), %r12 # 0x44c686
leaq 0x422fe3(%rip), %r13 # 0x449422
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rbp, %r15
je 0x264b0
vmovsd (%r15), %xmm0
vucomisd %xmm0, %... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_constraints<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&) | void
write_constraints(FormatContext& ctx, const Problem& pb)
{
for (std::size_t i = 0, e = pb.equal_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.equal_constraints[i], " = ");
for (std::size_t i = 0, e = pb.greater_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rsi), %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x48(%rsi), %rax
pushq $0x30
popq %r13
cqto
leaq 0x428b9a(%rip), %r12 # 0x44f151
xorl %ebp, %ebp
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x265e0
movq 0x48(%rbx), %rdx
movq %r1... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_constraint<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, baryonyx::constraint>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&, baryonyx::constraint const&, char const*) | void
write_constraint(FormatContext& ctx,
const Problem& p,
const Constraint& cst,
const char* separator)
{
if (!cst.label.empty())
fmt::format_to(ctx.out(), "{}: ", cst.label);
write_function_element(ctx, p, cst.elements);
fmt::format_to(ctx.out(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdx)
je 0x26739
movq (%r14), %rdi
leaq 0x425f81(%rip), %rsi # 0x44c6b2
movq %rbx, %rdx
callq 0x25cec
leaq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2676d
movq (%r14), %rd... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&,... | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %r12
leaq 0x422c9c(%rip), %r13 # 0x449422
leaq 0x425ef8(%rip), %rbp # 0x44c685
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r12, %r15
je 0x267f1
cmpl $0x0, (%r15)
js 0x267bf
je 0x267e0
movslq 0x4(%r15), %rcx
mo... | /quesnel[P]baryonyx/lib/src/problem.hpp |
baryonyx::itm::init_with_random(baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, double) | inline void
init_with_random(bit_array& x,
random_engine& rng,
const int variables,
const double init_ramdom) noexcept
{
std::bernoulli_distribution dist(init_ramdom);
for (int i = 0; i != variables; ++i)
if (dist(rng))
x.set(i);
el... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
vmovsd %xmm0, (%rsp)
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
cmpl %ebp, %ebx
je 0x28564
movq %r14, %rdi
callq 0x28d39
vmovsd (%rsp), %xmm1
movq %r15, %rdi
movl %ebp, %esi
vucomisd %xmm0, %xmm1
jbe 0x2855b
callq 0x28c3e
jmp 0x28560
callq 0x28... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::default_cost_type<float>::results(baryonyx::bit_array const&, double) const | double results(const bit_array& x, double cost_constant) const noexcept
{
for (int i = 0, e = length(obj.elements); i != e; ++i)
if (x[obj.elements[i].variable_index])
cost_constant += obj.elements[i].factor;
return cost_constant;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movabsq $0xffffffff0, %r15 # imm = 0xFFFFFFFF0
vmovsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x8(%rax), %rcx
subq (%rax), %rcx
andq %rcx, %r15
cmpq %r12, %r15
je 0x288af
movq (%r14), %rax
movq %rbx, %rdi
movq (%r... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
char* fmt::v7::detail::write<char, char*, unsigned __int128, 0>(char*, unsigned __int128) | OutputIt write(OutputIt out, T value) {
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(abs_value);
auto size ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10073
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x100e7
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_nonfinite<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char... | OutputIt write_nonfinite(OutputIt out, bool isinf,
const basic_format_specs<Char>& specs,
const float_specs& fspecs) {
auto str =
isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
constexpr size_t str_size = 3;
auto sign = fspecs.sign;... | subq $0x18, %rsp
movl 0x4(%rcx), %r8d
leaq 0x41f135(%rip), %rax # 0x449fb0
leaq 0x41f12a(%rip), %rcx # 0x449fac
leaq 0x41f12b(%rip), %r9 # 0x449fb4
btl $0x10, %r8d
cmovaeq %rax, %rcx
leaq 0x41f11f(%rip), %rax # 0x449fb8
cmovaeq %rax, %r9
testl %esi, %esi
movq %rdx, %rsi
cmovneq %rcx, %r9
shrl $0x8, %r8d
xo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator... | OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x40(%rsp)
movb %r8b, 0xf(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, %rdi
movq %rcx, %rbp
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movl %r8d, 0x3c(%rsp)
movl (%rsi), %eax
movl %eax, 0x50(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x10de3
movq... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::fill<char*, char>(char*, unsigned long, fmt::v7::detail::fill_t<char> const&) | FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
auto fill_size = fill.size();
if (fill_size == 1) return std::fill_n(it, n, fill[0]);
for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);
return it;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x4(%rdx), %r12d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, %r12
jne 0x2b354
testq %r14, %r14
je 0x2b345
movzbl (%r15), %esi
leaq (%rbx,%r14), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9180
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
p... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::dragonbox::decimal_fp<float> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> ... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %edi
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
callq 0x10ac5
movl %eax, %eax
xorl %r12d, %r12d
subq %rbp, %rax
movzbl 0xe(%r14), %esi
leaq 0x41f204(%rip), %rcx # 0x44ab09
movq %rbx, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(std::back_insert_iterato... | OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x38(%rsp)
movb %r8b, 0xb(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, %rdi
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movl %r8d, 0x34(%rsp)
movq (%rsi), %rax
movq %rax, 0x58(%rsp)
movq %rax, 0x40(%rsp)
callq 0x12123
movq... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::dragonbox::decimal_fp<double> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %edi
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
callq 0x10ac5
movl %eax, %eax
xorl %r12d, %r12d
subq %rbp, %rax
movzbl 0xe(%r14), %esi
leaq 0x41ea51(%rip), %rcx # 0x44ab09
movq %rbx, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::dragonbox::decimal_fp<double> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %edi
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
callq 0x10ac5
movl %eax, %eax
xorl %r12d, %r12d
subq %rbp, %rax
movzbl 0xe(%r14), %esi
leaq 0x41e921(%rip), %rcx # 0x44ab09
movq %rbx, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.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.