name string | code string | asm string | file string |
|---|---|---|---|
int fmt::v8::detail::snprintf_float<double>(double, int, fmt::v8::detail::float_specs, fmt::v8::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 $0x38, %rsp
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rdx), %rax
cmpq 0x10(%rdx), %rax
jbe 0xbc3f6
movq %rdx, %rbx
shrq $0x20, %rsi
leal -0x1(%rdi), %eax
testl %edi, %edi
movl $0x5, %r14d
cmovnsl %eax, %r14d
cmpb $0x2, %sil
cmovael %edi, %r14d
movb $0x25, ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
int fmt::v8::detail::snprintf_float<long double>(long double, int, fmt::v8::detail::float_specs, fmt::v8::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 $0x48, %rsp
fldt 0x80(%rsp)
fstpt 0x34(%rsp)
movq 0x18(%rdx), %rax
cmpq 0x10(%rdx), %rax
jbe 0xbc76e
movq %rdx, %rbx
shrq $0x20, %rsi
leal -0x1(%rdi), %eax
testl %edi, %edi
movl $0x5, %r14d
cmovnsl %eax, %r14d
cmpb $0x2, %sil
cmovael %edi, %r14d
mov... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
int fmt::v8::detail::format_float<double>(double, int, fmt::v8::detail::float_specs, fmt::v8::detail::buffer<char>&) | FMT_HEADER_ONLY_CONSTEXPR20 int format_float(Float value, int precision,
float_specs specs,
buffer<char>& buf) {
// float is passed as double to reduce the number of instantiations.
static_assert(!std::is_same<Float, float>::v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xbce78
movq %rdx, %r14
movl %edi, %r13d
movabsq $0xff00000000, %r8 # imm = 0xFF00000000
andq %rsi, %r8
movabsq $0x200000000, %r9 # imm = 0x200000000
cmpq %r9, %r8
sete %dil
ucomisd %... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, unsigned int, 0>(fmt::v8::appender, unsigned int) | FMT_INLINE auto do_count_digits(uint32_t n) -> int {
// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
# define FMT_INC(T) (((sizeof(# T) - 1ull) << 32) - T)
static constexpr uint64_t table[] = {
FMT_INC(0), FMT_... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %eax
orl $0x1, %eax
bsrl %eax, %ecx
leaq 0x3ee05(%rip), %rdx # 0xfbd50
movl %esi, %eax
addq (%rdx,%rcx,8), %rax
movq %rdi, %rbx
movq %rax, %rdx
shrq $0x20, %rdx
sarq $0x20, %rax
movq 0x10(%rdi), %rdi
addq %rdi, %rax
cmpq %rax, 0x18(%rbx)
jae 0xbcf70
xorl %edi, %edi
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::format_dragon(fmt::v8::detail::fp, bool, int, fmt::v8::detail::buffer<char>&, int&) | FMT_CONSTEXPR20 inline void format_dragon(fp value, bool is_predecessor_closer,
int num_digits, buffer<char>& buf,
int& exp10) {
bigint numerator; // 2 * R in (FPP)^2.
bigint denominator; // 2 * S in (FPP)^2.
// lower and uppe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %rax
movups %xmm0, 0x8(%rax)
leaq 0x6ecb1(%rip), %rcx # 0x12bd10
movq %rcx, (%ra... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
wchar_t fmt::v8::detail::decimal_point_impl<wchar_t>(fmt::v8::detail::locale_ref) | Locale locale_ref::get() const {
static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
} | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xbda1f
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0xc570
jmp 0xbda29
leaq 0x8(%rsp), %rdi
callq 0xd3a0
leaq 0x8(%rsp), %rdi
callq 0xcf40
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xcd80
movl %ebx, %eax
addq $0x10, %rsp... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
void fmt::v8::detail::buffer<wchar_t>::append<wchar_t>(wchar_t const*, wchar_t 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));
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0xbdada
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %r12
subq %r14, %r12
sarq $0x2, %r12
js 0xbdae4
movq 0x10(%r15), %rsi
addq %r12, %rsi
cmpq %rsi, 0x18(%r15)
jae 0xbda9e
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x10(%... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::get_round_direction(unsigned long, unsigned long, unsigned long) | FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor,
uint64_t remainder,
uint64_t error) {
FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow.
FMT_ASSERT(e... | pushq %rax
movq %rdi, %rax
subq %rsi, %rax
jbe 0xbdb60
movq %rdi, %rcx
subq %rdx, %rcx
jbe 0xbdb78
cmpq %rdx, %rcx
jbe 0xbdb90
cmpq %rsi, %rax
jb 0xbdb4a
leaq (%rdx,%rdx), %rcx
movq %rdi, %r8
subq %rsi, %r8
subq %rsi, %r8
movl $0x2, %eax
cmpq %r8, %rcx
jbe 0xbdb5e
subq %rdx, %rsi
jb 0xbdb5c
subq %rsi, %rdi
movl $0x1, %... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::add_compare(fmt::v8::detail::bigint const&, fmt::v8::detail::bigint const&, fmt::v8::detail::bigint const&) | FMT_CONSTEXPR20 int num_bigits() const {
return static_cast<int>(bigits_.size()) + exp_;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0xa8(%rdi), %ecx
movl 0x10(%rdi), %r8d
addl %ecx, %r8d
movl 0xa8(%rsi), %r9d
movl 0x10(%rsi), %r10d
addl %r9d, %r10d
cmpl %r10d, %r8d
movl %r10d, %r14d
cmovgl %r8d, %r14d
movl 0x10(%rdx), %r11d
movl 0xa8(%rdx), %ebx
leal (%rbx,%r11)... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::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) {
#ifdef FMT_FUZZ
if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0x18(%rbx), %rax
movq %rax, %r14
shrq %r14
addq %rax, %r14
cmpq %rsi, %r14
jae 0xbe22d
movq %rsi, %r14
jmp 0xbe247
movq %r14, %rax
shrq $0x3d, %rax
je 0xbe247
movabsq $0x1fffffffffffffff, %r14 # imm = 0x1FFFFFFFFFFFFFFF
cmpq %r... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::bigint::remove_leading_zeros() | FMT_CONSTEXPR20 void remove_leading_zeros() {
int num_bigits = static_cast<int>(bigits_.size()) - 1;
while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
bigits_.resize(to_unsigned(num_bigits + 1));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
movl %eax, %esi
testl %eax, %eax
movl $0x1, %edx
cmovlel %eax, %edx
incl %eax
cmpl $0x2, %esi
jl 0xbe499
decl %eax
cmpl $0x0, -0x4(%rcx,%rsi,4)
leaq -0x1(%rsi), %rsi
je 0xbe485
jmp 0xbe49b
movl %edx, %eax
testl %eax, %eax
js 0xb... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v8::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&) | FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
alloc_ = std::move(other.alloc_);
T* data = other.data();
size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
if (detail::is_constant_evaluated()) {
detail::copy_str<... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rcx
addq $0x20, %rsi
cmpq %rsi, %rdx
je 0xbe517
movq %rdx, 0x8(%rbx)
movq %rcx, 0x18(%rbx)
movq %rsi, 0x8(%rax)
movq $0x0, 0x18(%rax)
jmp 0xbe535
leaq 0x20(%rbx), %rdi
movq %rdi, 0x8(%rbx)
movq ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::bigint::multiply(unsigned long) | FMT_CONSTEXPR20 void multiply(uint64_t value) {
const bigit mask = ~bigit(0);
const double_bigit lower = value & mask;
const double_bigit upper = value >> bigit_bits;
double_bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
double_bigit result = bigits_[i] * lower + (carry ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xbe5ae
movl %esi, %ecx
shrq $0x20, %rsi
movq 0x8(%rbx), %rdx
xorl %r14d, %r14d
xorl %edi, %edi
movl (%rdx,%rdi,4), %r8d
movq %rcx, %r9
imulq %r8, %r9
movl %r14d, %r10d
addq %r9, %r10
imulq %rsi, %r8
movl %r10d, (%rdx,%rdi,4)
shr... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::bigint::align(fmt::v8::detail::bigint const&) | FMT_CONSTEXPR20 void align(const bigint& other) {
int exp_difference = exp_ - other.exp_;
if (exp_difference <= 0) return;
int num_bigits = static_cast<int>(bigits_.size());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0xa8(%rdi), %r15d
subl 0xa8(%rsi), %r15d
jle 0xbe67a
movq %rdi, %rbx
movl 0x10(%rdi), %r12d
movl %r15d, %eax
addl %r12d, %eax
js 0xbe686
movl %eax, %r14d
cmpq %r14, 0x18(%rbx)
jae 0xbe629
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x1... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::bigint::subtract_aligned(fmt::v8::detail::bigint const&) | FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) {
FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
FMT_ASSERT(compare(*this, other) >= 0, "");
bigit borrow = 0;
int i = other.exp_ - exp_;
for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
subtract_bigits(i, other.big... | pushq %r14
pushq %rbx
pushq %rax
movl 0xa8(%rsi), %eax
cmpl 0xa8(%rdi), %eax
jl 0xbe773
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbdf81
testl %eax, %eax
js 0xbe78b
movl 0xa8(%r14), %eax
subl 0xa8(%rbx), %eax
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xbe723
movq 0x8(%r14), %r8
movl %eax, %edx
leaq (,%rdx,4), %r9
addq 0x8... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::bigint::multiply(unsigned int) | FMT_CONSTEXPR20 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 >> ... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xbe7dd
movl %eax, %eax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
xorl %r14d, %r14d
movl (%rcx,%rdx,4), %edi
imulq %rax, %rdi
addq %rdi, %r14
movl %r14d, (%rcx,%rdx,4)
shrq $0x20, %r14
incq %rdx
cmpq %rdx, %rsi
jne 0xb... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::format_string_checker<char, fmt::v8::detail::error_handler, fmt::v8::basic_string_view<char>, char [3]>::on_format_specs(int, char const*, char const*) | constexpr auto begin() const FMT_NOEXCEPT -> iterator { return data_; } | movq (%rdi), %rcx
movq %rdx, %rax
subq %rcx, %rax
js 0xbe906
addq %rax, %rcx
movq %rcx, (%rdi)
subq %rax, 0x8(%rdi)
cmpl $0x1, %esi
ja 0xbe902
movl %esi, %eax
jmpq *0x18(%rdi,%rax,8)
movq %rdx, %rax
retq
pushq %rax
leaq 0x3cdc1(%rip), %rdi # 0xfb6cf
leaq 0x3ce2e(%rip), %rdx # 0xfb743
movl $0x1aa, %esi ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
int fmt::v8::detail::parse_nonnegative_int<char>(char const*&, char const*, int) | FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
int error_value) noexcept -> int {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0, prev = 0;
auto p = begin;
do {
prev = value;
value = value * 10 + ... | pushq %rax
movq (%rdi), %rcx
cmpq %rsi, %rcx
je 0xbeac1
movb (%rcx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0xbeac1
xorl %eax, %eax
movq %rcx, %r10
movl %eax, %r9d
movq %r10, %r8
leal (%r9,%r9,4), %eax
movsbl (%r10), %r10d
leal (%r10,%rax,2), %eax
addl $-0x30, %eax
leaq 0x1(%r8), %r10
cmpq %rsi, %r10
je 0xbea8e
movb (%... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
decltype(fp.begin()) fmt::v8::detail::parse_format_specs<char [3], fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>(fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>&) | FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
-> decltype(ctx.begin()) {
using char_type = typename ParseContext::char_type;
using context = buffer_context<char_type>;
using mapped_type = conditional_t<
mapped_type_constant<T, context>::value != type::custom_type,
decltype(arg_mapper<co... | subq $0x48, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movl $0xffffffff, 0x4(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x8(%rax)
andw $0xfe00, 0x9(%rax) # imm = 0xFE00
movq %rdi, %rsi
movl $0x20, 0xb(%rax)
movb $0x1, 0xf(%rax)
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
fmt::v8::presentation_type fmt::v8::detail::parse_presentation_type<char>(char) | FMT_CONSTEXPR auto parse_presentation_type(Char type) -> presentation_type {
switch (to_ascii(type)) {
case 'd':
return presentation_type::dec;
case 'o':
return presentation_type::oct;
case 'x':
return presentation_type::hex_lower;
case 'X':
return presentation_type::hex_upper;
case 'b':
... | leal -0x61(%rdi), %eax
cmpl $0x17, %eax
ja 0xbed55
leaq 0x3c56b(%rip), %rcx # 0xfb2b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x7, %al
retq
leal -0x41(%rdi), %eax
cmpl $0x6, %eax
ja 0xbed70
leaq 0x3c534(%rip), %rcx # 0xfb298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x8, %a... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
fmt::v8::detail::specs_checker<fmt::v8::detail::dynamic_specs_handler<fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>>::on_sign(fmt::v8::sign::type) | FMT_CONSTEXPR void on_sign(sign_t s) {
require_numeric_argument();
if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
this->on_error("format specifier requires signed argument");
}
Handler::on_sign(s);
} | pushq %rax
movl 0x18(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
jae 0xbeeda
cmpl $0x7, %ecx
ja 0xbeec2
cmpl $0x8, %eax
ja 0xbeee6
movl $0x10a, %ecx # imm = 0x10A
btl %eax, %ecx
jae 0xbeee6
movq (%rdi), %rax
movzwl 0x9(%rax), %ecx
shll $0x4, %esi
andl $0x70, %esi
andl $-0x71, %ecx
orl %esi, %ecx
movw %... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::parse_width<char, fmt::v8::detail::specs_checker<fmt::v8::detail::dynamic_specs_handler<fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::dynamic_specs_handler<fmt::v8::detail::compile_p... | FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
using detail::auto_id;
struct width_adapter {
Handler& handler;
FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
FMT_CONSTEXPR void operator()(in... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, (%rsp)
cmpq %rsi, %rdi
je 0xbefe3
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xbef6d
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xbea4b
cmpl $-0x1, %eax
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::parse_precision<char, fmt::v8::detail::specs_checker<fmt::v8::detail::dynamic_specs_handler<fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::dynamic_specs_handler<fmt::v8::detail::compi... | FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
using detail::auto_id;
struct precision_adapter {
Handler& handler;
FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
FMT_CONSTEXPR vo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
cmpq %rsi, %rax
je 0xbf037
movsbl (%rax), %eax
jmp 0xbf039
xorl %eax, %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xbf062
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::do_parse_arg_id<char, char const* fmt::v8::detail::parse_width<char, fmt::v8::detail::specs_checker<fmt::v8::detail::dynamic_specs_handler<fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detai... | FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) -> const Char* {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index =
parse_nonnegative_int(begin, end, ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0xbf25e
movq %rdx, %rbx
movq %rsi, %r14
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xbf18b
cmpb $0x30, %al
jne 0xbf1fa
incq %rdi
movq %rdi, 0x8(%rsp)
xorl %ebp, %ebp
jmp 0xbf20e
cmpb $0x5f, %al
je 0xbf19b
andb $-0x2... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
decltype(fp.begin()) fmt::v8::formatter<char const*, char, void>::parse<fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>(fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>&) | constexpr auto begin() const FMT_NOEXCEPT -> iterator { return data_; } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xbf534
movq %rdi, %r14
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl $0xc, 0x18(%rsp)
cmpq $0x2, %r15
jl 0xbf41f
cmpb $0x7d, 0x1(%rbx)
jne 0xbf41f
movb (%rbx), %al
cmpb $0x4c, %al
je 0xbf41f... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::parse_replacement_field<char, fmt::v8::detail::format_string_checker<char, fmt::v8::detail::error_handler, char [7], int>&>(char const*, char const*, fmt::v8::detail::format_string_checker<char, fmt::v8::detail::error_handler, char [7], int>&) | FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
struct id_adapter {
Handler& handler;
int arg_id;
FMT_CONSTEXPR void operator()() { arg_id = handler.on_arg_id(); }
FMT_CONSTEXPR void operator... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incq %rbx
cmpq %rsi, %rbx
je 0xbf605
movzbl (%rbx), %eax
cmpl $0x7b, %eax
je 0xbf5f5
movq %rdx, %r15
cmpl $0x7d, %eax
jne 0xbf58b
movq %r15, %rdi
callq 0xbe920
jmp 0xbf5f5
movq %rsi, %r14
movq %r15, (%rsp)
movl $0x0, 0x8(%rsp)
cmpb $0x3a, %al
jne 0xbf5ac... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
fmt::v8::detail::format_string_checker<char, fmt::v8::detail::error_handler, char [7], int>::on_format_specs(int, char const*, char const*) | constexpr auto begin() const FMT_NOEXCEPT -> iterator { return data_; } | movq (%rdi), %rcx
movq %rdx, %rax
subq %rcx, %rax
js 0xbf64e
addq %rax, %rcx
movq %rcx, (%rdi)
subq %rax, 0x8(%rdi)
cmpl $0x1, %esi
ja 0xbf64a
movl %esi, %eax
jmpq *0x18(%rdi,%rax,8)
movq %rdx, %rax
retq
pushq %rax
leaq 0x3c079(%rip), %rdi # 0xfb6cf
leaq 0x3c0e6(%rip), %rdx # 0xfb743
movl $0x1aa, %esi ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::do_parse_arg_id<char, char const* fmt::v8::detail::parse_replacement_field<char, fmt::v8::detail::format_string_checker<char, fmt::v8::detail::error_handler, char [7], int>&>(char const*, char const*, fmt::v8::detail::format_string_checker<char, fmt::v8::detail::error_handler, char [7], int... | FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) -> const Char* {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index =
parse_nonnegative_int(begin, end, ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0xbf6e0
movq %rsi, %rbx
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xbf6f8
movq %rdx, %r14
cmpb $0x30, %al
jne 0xbf699
incq %rdi
movq %rdi, 0x8(%rsp)
xorl %ebp, %ebp
jmp 0xbf6ad
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
decltype(fp.begin()) fmt::v8::detail::parse_format_specs<char [7], fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>(fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>&) | FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
-> decltype(ctx.begin()) {
using char_type = typename ParseContext::char_type;
using context = buffer_context<char_type>;
using mapped_type = conditional_t<
mapped_type_constant<T, context>::value != type::custom_type,
decltype(arg_mapper<co... | subq $0x48, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movl $0xffffffff, 0x4(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x8(%rax)
andw $0xfe00, 0x9(%rax) # imm = 0xFE00
movq %rdi, %rsi
movl $0x20, 0xb(%rax)
movb $0x1, 0xf(%rax)
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
decltype(fp.begin()) fmt::v8::detail::parse_format_specs<int, fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>(fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>&) | FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
-> decltype(ctx.begin()) {
using char_type = typename ParseContext::char_type;
using context = buffer_context<char_type>;
using mapped_type = conditional_t<
mapped_type_constant<T, context>::value != type::custom_type,
decltype(arg_mapper<co... | subq $0x48, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movl $0xffffffff, 0x4(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x8(%rax)
andw $0xfe00, 0x9(%rax) # imm = 0xFE00
movq %rdi, %rsi
movl $0x20, 0xb(%rax)
movb $0x1, 0xf(%rax)
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
decltype(fp.begin()) fmt::v8::formatter<int, char, void>::parse<fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>>(fmt::v8::detail::compile_parse_context<char, fmt::v8::detail::error_handler>&) | constexpr auto begin() const FMT_NOEXCEPT -> iterator { return data_; } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rsi), %r14
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xbf976
movq %rdi, %rbx
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
cmpq $0x2, %r15
jl 0xbf863
cmpb $0x7d, 0x1(%r14)
jne 0xbf863
movb (%r14), %al
cmpb $0x4c, %al
je 0xbf863... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
fmt::v8::basic_memory_buffer<wchar_t, 500ul, std::allocator<wchar_t>>::grow(unsigned long) | FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
#ifdef FMT_FUZZ
if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x7f0, %rdi # imm = 0x7F0
movq 0x18(%rbx), %rax
movq %rax, %r14
shrq %r14
addq %rax, %r14
cmpq %rsi, %r14
jae 0xbfa5f
movq %rsi, %r14
jmp 0xbfa79
movq %r14, %rax
shrq $0x3d, %rax
je 0xbfa79
movabsq $0x1fffffffffffffff, %r14 # imm = ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
std::back_insert_iterator<fmt::v8::detail::buffer<char>> fmt::v8::detail::copy_str<char, char const*, std::back_insert_iterator<fmt::v8::detail::buffer<char>>>(char const*, char const*, std::back_insert_iterator<fmt::v8::detail::buffer<char>>) | FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out)
-> OutputIt {
while (begin != end) *out++ = static_cast<Char>(*begin++);
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq %rsi, %rdi
je 0xbfb3b
movq %rsi, %r14
movq %rdi, %r15
movb (%r15), %bpl
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0xbfb1f
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
incq %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
fmt::v8::appender fmt::v8::detail::default_arg_formatter<char>::operator()<bool>(bool) | 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)
andw $0xfe00, 0x9(%rdx) # imm = 0xFE00
movl $0x20, 0xb(%rdx)
movb $0x1, 0xf(%rdx)
xorl %ecx, %ecx
callq 0xc0288
addq $0x18, %rsp
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, int, 0>(fmt::v8::appender, int) | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(ab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
negl %r14d
cmovsl %esi, %r14d
movl %r14d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x3c167(%rip), %rcx # 0xfbd50
movq (%rcx,%rax,8), %rcx
addq %r14, %rcx
movq %rcx, %r15
shrq $0x20, %r15
movl %es... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::format_decimal_result<char*> fmt::v8::detail::format_decimal<char, unsigned int>(char*, unsigned int, int) | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for... | pushq %rax
movl %esi, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x3c09c(%rip), %rcx # 0xfbd50
movl %esi, %r8d
addq (%rcx,%rax,8), %r8
shrq $0x20, %r8
cmpl %edx, %r8d
jg 0xbfd2f
movslq %edx, %rax
addq %rax, %rdi
leaq 0x3bd5d(%rip), %rcx # 0xfba2e
movq %rdi, %rax
cmpl $0x64, %esi
jb 0xbfd0a
movl %esi, %edx
imulq $... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, long long, 0>(fmt::v8::appender, long long) | 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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rsi, %r14
negq %r14
cmovsq %rsi, %r14
movq %r14, %rax
orq $0x1, %rax
bsrq %rax, %rax
leaq 0x3cd16(%rip), %rcx # 0xfcaa0
movzbl (%rax,%rcx), %r15d
leaq 0x3cd4a(%rip), %rax # 0xfcae0
cmpq (%rax,%r15,8), %r14
sbbq $0x0, %... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::format_decimal_result<char*> fmt::v8::detail::format_decimal<char, unsigned long>(char*, unsigned long, int) | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for... | pushq %rax
movq %rsi, %rax
orq $0x1, %rax
bsrq %rax, %rax
leaq 0x3cc41(%rip), %rcx # 0xfcaa0
movzbl (%rax,%rcx), %eax
leaq 0x3cc76(%rip), %rcx # 0xfcae0
cmpq (%rcx,%rax,8), %rsi
sbbl $0x0, %eax
cmpl %edx, %eax
jg 0xbfef4
movslq %edx, %rax
addq %rax, %rdi
leaq 0x3bbac(%rip), %r8 # 0xfba2e
cmpq $0x64, %rsi
j... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, unsigned long long, 0>(fmt::v8::appender, unsigned long long) | 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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, %rax
orq $0x1, %rax
bsrq %rax, %rax
leaq 0x3cb78(%rip), %rcx # 0xfcaa0
movzbl (%rax,%rcx), %edx
leaq 0x3cbad(%rip), %rax # 0xfcae0
cmpq (%rax,%rdx,8), %rsi
sbbq $0x0, %rdx
movq 0x10(%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq %rax, 0x18(%rbx)
jae 0xb... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, __int128, 0>(fmt::v8::appender, __int128) | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(ab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0xbffa9
movq %r12, %r15
jmp 0xbffb2
xorl %r15d, %r15d
negq %r14
sbbq %r12, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc015e
movl %eax, %ebp
movq %r12, %rcx
shrq $0x3f,... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
int fmt::v8::detail::count_digits_fallback<unsigned __int128>(unsigned __int128) | FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {
int count = 1;
for (;;) {
// Integer division is slow so do it for a group of four digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
if (n < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpq $0xa, %rdi
movq %rsi, %rax
sbbq $0x0, %rax
jb 0xc01f5
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %ebx
movl $0x63, %r12d
movl $0x3e7, %r13d # imm = 0x3E7
movl $0x1869f, %ebp # imm = 0x1869F
cmpq %r15, %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
bool fmt::v8::detail::write_int_localized<fmt::v8::appender, unsigned long, char>(fmt::v8::appender&, unsigned long, unsigned int, fmt::v8::basic_format_specs<char> const&, fmt::v8::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 0xc09c6
movq (%rbx), %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %r12, %r8
callq 0xc0a96
movq %r... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::digit_grouping<char>::digit_grouping(fmt::v8::detail::locale_ref, bool) | explicit digit_grouping(locale_ref loc, bool localized = true) {
if (localized)
sep_ = thousands_sep<Char>(loc);
else
sep_.thousands_sep = Char();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
je 0xc0a56
leaq 0x8(%rsp), %rdi
callq 0xbbe9b
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::fill<fmt::v8::appender, char>(fmt::v8::appender, unsigned long, fmt::v8::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 0xc0cc3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc0ced
testq %r14, %r14
je 0xc0cde
addq %rbx, %r12
movq ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::digit_grouping<char>::apply<fmt::v8::appender, char>(fmt::v8::appender, fmt::v8::basic_string_view<char>) const | Out apply(Out out, basic_string_view<C> digits) const {
auto num_digits = static_cast<int>(digits.size());
auto separators = basic_memory_buffer<int>();
separators.push_back(0);
auto state = initial_state();
while (int i = next(state)) {
if (i >= num_digits) break;
separators.push_back(i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp # imm = 0x808
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
movups %xmm0, -0x18(%rcx)
leaq 0x6b07e(%rip), %rax # 0x12bde8
movq %rax, -0x20(%rcx)
movq %rcx, -... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned int>(fmt::v8::appender, fmt::v8::detail::write_int_arg<unsigned int>, fmt::v8::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
movslq (%rsi), %rax
testq %rax, %rax
js 0xc1149
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3abb0(%rip), %rcx # 0xfbc34
movb (%rax,... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned int>(fmt::v8::appender, fmt::v8::detail::write_int_arg<unsigned int>, fmt::v8::basic_f... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc13cb
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x3a8c1(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
char fmt::v8::detail::write_padded<(fmt::v8::align::type)1, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_bytes<(fmt::v8::align::type)1, char, fmt::v8::appender>(fmt::v8::appender, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_specs<char> const&)::'lambda'(fmt::v8::appender)&>(char, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc17f8
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3a4a4(%rip), %rcx # 0xfbc39
movb (%rax,%rcx), %cl
movq %r15, %r13
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, float, 0>(fmt::v8::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;
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using uin... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movd %xmm0, %eax
movq $0x0, 0x8(%rsp)
testl %eax, %eax
jns 0xc1836
movb $0x1, 0xd(%rsp)
pxor 0x1cfea(%rip), %xmm0 # 0xde820
movups 0x39b23(%rip), %xmm1 # 0xfb360
movaps %xmm1, 0x10(%rsp)
notl %eax
testl $0x7f800000, %eax # imm = 0x7F800000
jne 0xc1878
movd %xmm0, ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_nonfinite<char, fmt::v8::appender>(fmt::v8::appender, bool, fmt::v8::basic_format_specs<char>, fmt::v8::detail::float_specs const&) | FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isinf,
basic_format_specs<Char> specs,
const float_specs& fspecs) -> OutputIt {
auto str =
isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
constexpr size_t... | subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x4(%r8), %eax
cmpb $0x1, 0x17(%rsp)
jne 0xc18c5
cmpb $0x30, 0x13(%rsp)
jne 0xc18c5
movb $0x20, 0x13(%rsp)
btl $0x10, %eax
leaq 0x3a24d(%rip), %rcx # 0xfbb1d
leaq 0x3a242(%rip), %rdx # 0xfbb19
cmovaeq %rcx, %rdx
leaq 0x3a243(%rip), %rcx # 0xfb... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)1, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_nonfinite<char, fmt::v8::appender>(fmt::v8::appender, bool, fmt::v8::basic_format_specs<char>, fmt::v8::detail::float_specs const&)::'lambda'(fmt::v8::appender)&>(fmt::v8::appender,... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0xc1a02
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3a2de(%rip), %rcx # 0xfbc39
movb (%rax,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_exponent<char, fmt::v8::appender>(int, fmt::v8::appender) | FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It {
FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
if (exp < 0) {
*it++ = static_cast<Char>('-');
exp = -exp;
} else {
*it++ = static_cast<Char>('+');
}
if (exp >= 100) {
const char* top = digits2(to_unsigned(exp / 100));... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %r14d
leal 0x270f(%r14), %eax
cmpl $0x4e1f, %eax # imm = 0x4E1F
jae 0xc22a1
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
movq 0x18(%rbx), %rax
incq %rsi
testl %r14d, %r14d
js 0xc216e
cmpq %rsi, %rax
jae 0xc2158
movq (%rbx), %rax
movq %rbx, %rdi
callq ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<float> fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<float>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detai... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc235a
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x39932(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_significand<char, fmt::v8::appender, unsigned int, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, unsigned int, int, int, fmt::v8::detail::digit_grouping<char> const&) | FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int exponent,
const Grouping& grouping) -> OutputIt {
if (!grouping.separator()) {
out = write_significand<Char>(out, significand, significand_siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r8)
je 0xc24e6
movq %r8, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movups %xmm0, -0x18(%r15)
leaq 0x698ee(%rip), %rax # 0x12bd68
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
m... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<float> fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<float>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::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
movslq (%rsi), %rax
testq %rax, %rax
js 0xc264d
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x396b8(%rip), %rcx # 0xfbc34
movb (%rax,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_significand<fmt::v8::appender, char, unsigned int, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, unsigned int, int, int, char, fmt::v8::detail::digit_grouping<char> const&) | FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int integral_size,
Char decimal_point,
const Grouping& grouping) -> OutputIt {
if (!grouping.separator()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp # imm = 0x230
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0xc270a
movq %r9, %r14
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %r12
movups %xmm0, -0x18(%r12)
leaq 0x696cc(%rip), %rax # 0x12bd68
movq %rax, -0x20(%r12)
movq %r12, -0... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, double, 0>(fmt::v8::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;
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using uin... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
movq $0x0, 0x8(%rsp)
testq %rax, %rax
jns 0xc2a88
movb $0x1, 0xd(%rsp)
pxor 0x35bc8(%rip), %xmm0 # 0xf8650
movups 0x388d1(%rip), %xmm1 # 0xfb360
movaps %xmm1, 0x10(%rsp)
notq %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<double>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<double> const&, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::float_specs, fmt::v8::det... | FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs,
float_specs fspecs, locale_ref loc)
-> OutputIt {
auto significand = fp.significand;
int significand_size = get_significand_size(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movq %rcx, 0x18(%rsp)
movq (%rsi), %rax
movq %rax, 0x28(%rsp)
movq %rax, %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
leaq 0x39f70(%rip), %rdx # 0xfcaa0
movzbl (%rcx,%rdx), %r15d
leaq 0x39fa4(%rip), %rcx # 0xfcae0
xorl %ed... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<double> fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<double>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::det... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc31b1
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x38adb(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<double> fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<double>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::det... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc3252
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x38a3a(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_significand<char, fmt::v8::appender, unsigned long, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, unsigned long, int, int, fmt::v8::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 0xc33d5
movq %r8, %r14
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r15
movups %xmm0, -0x18(%r15)
leaq 0x689f9(%rip), %rax # 0x12bd68
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
m... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<double> fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<double>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::det... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0xc353d
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x387c9(%rip), %rcx # 0xfbc34
movb (%rax,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_significand<fmt::v8::appender, char, unsigned long, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, unsigned long, int, int, char, fmt::v8::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 0xc3616
movq %r9, %r14
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movups %xmm0, -0x18(%r12)
leaq 0x687d8(%rip), %rax # 0x12bd68
movq %rax... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<double> fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::dragonbox::decimal_fp<double>, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::det... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc387d
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x3840f(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::float_specs fmt::v8::detail::parse_float_type_spec<fmt::v8::detail::error_handler, char>(fmt::v8::basic_format_specs<char> const&, fmt::v8::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 0xc3cd9
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x1, %ecx
movl %ecx, %esi
shll $0x14, %esi
shll $0x9, %eax
andl $0x20000, %eax # imm = 0x20000
orl %esi, %eax
leaq 0x3770b(%rip), %rsi # 0xfb384
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%r... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_bytes<(fmt::v8::align::type)2, char, fmt::v8::appender>(fmt::v8::appender, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_specs<char> const&)::'lambda'(fmt::v8::appender)&>(char, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc3d7f
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x37f18(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r15, %r13
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::big_decimal_fp, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detail::big_decimal_fp const&, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::float_specs, fmt::v8::detail::locale_ref) | FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs,
float_specs fspecs, locale_ref loc)
-> OutputIt {
auto significand = fp.significand;
int significand_size = get_significand_size(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x18(%rsp)
movq (%rsi), %rax
movq %rax, 0x28(%rsp)
movl 0x8(%rsi), %r15d
movl %r15d, 0x14(%rsp)
movb $0x30, 0xf(%rsp)
movl 0x1c(%rsp), %ecx
movzbl %ch, %eax
movl %eax, 0x24(%rsp)
testl %r15d, %r15d
js 0xc428e
movq %r8, %rbp
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::big_decimal_fp fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::big_decimal_fp, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detail::big_decimal_fp const&, fm... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0xc4402
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x37933(%rip), %rcx # 0xfbc34
movb (%rax,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_significand<fmt::v8::appender, char>(fmt::v8::appender, char const*, int, int, char) | FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
int significand_size, int integral_size,
Char decimal_point) -> OutputIt {
out = detail::copy_str_noinline<Char>(significand,
si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rdx
movslq %ecx, %r15
addq %rsi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0xc449e
movq %rax, %r12
testb %bpl, %bpl
je 0xc4492
movq 0x10(%r12), %rsi
incq %rsi
cmpq %rsi, 0x18(%r12)
jae 0xc445f
movq (%r12... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::big_decimal_fp fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::big_decimal_fp, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detail::big_decimal_fp const&, fm... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc453e
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x3774e(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::big_decimal_fp fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::big_decimal_fp, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detail::big_decimal_fp const&, fm... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0xc4812
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x374f4(%rip), %rcx # 0xfbc34
movb (%rax,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_significand<fmt::v8::appender, char, char const*, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, char const*, int, int, char, fmt::v8::detail::digit_grouping<char> const&) | FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int integral_size,
Char decimal_point,
const Grouping& grouping) -> OutputIt {
if (!grouping.separator()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0xc48db
movq %r9, %r14
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r12
movups %xmm0, -0x18(%r12)
leaq 0x67507(%rip), %rax # 0x12bd68
movq %rax, -0x20(%r12)
movq %r12, -0... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::big_decimal_fp fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::do_write_float<fmt::v8::appender, fmt::v8::detail::big_decimal_fp, char, fmt::v8::detail::digit_grouping<char>>(fmt::v8::appender, fmt::v8::detail::big_decimal_fp const&, fm... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc49b3
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x372d9(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_ptr<char, fmt::v8::appender, unsigned long>(fmt::v8::appender, unsigned long, fmt::v8::basic_format_specs<char> const*) | auto write_ptr(OutputIt out, UIntPtr value,
const basic_format_specs<Char>* specs) -> OutputIt {
int num_digits = count_digits<4>(value);
auto size = to_unsigned(num_digits) + size_t(2);
auto write = [=](reserve_iterator<OutputIt> it) {
*it++ = static_cast<Char>('0');
*it++ = static_cast<Ch... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x2, %ecx
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x4, %rax
incq %rcx
cmpq $0xf, %rdi
movq %rax, %rdi
ja 0xc4b28
movq %rsi, (%rsp)
leal -0x2(%rcx), %eax
movl %eax, 0x8(%rsp)
testq %rdx, %rdx
je 0xc4b61
movq %rsp, %r8
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
void fmt::v8::detail::vformat_to<char>(fmt::v8::detail::buffer<char>&, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<std::conditional<std::is_same<fmt::v8::type_identity<char>::type, char>::value, fmt::v8::appender, std::back_insert_iterator<fmt::v8::detail::buffer<fmt::v8::... | auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
buffer<T>& buf = get_container(it);
auto size = buf.size();
if (buf.capacity() < size + n) return nullptr;
buf.try_resize(size + n);
return buf.data() + size;
} | pushq %rbx
subq %rsi, %rdx
js 0xc4e5e
movq %rdi, %rbx
movq 0x20(%rdi), %rax
addq %rsi, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xc449e
movq %rax, 0x20(%rbx)
popq %rbx
retq
leaq 0x3686a(%rip), %rdi # 0xfb6cf
leaq 0x368d7(%rip), %rdx # 0xfb743
movl $0x1aa, %esi # imm = 0x1AA
callq 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
void fmt::v8::detail::parse_format_string<false, char, void fmt::v8::detail::vformat_to<char>(fmt::v8::detail::buffer<char>&, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<std::conditional<std::is_same<fmt::v8::type_identity<char>::type, char>::value, fmt::v8::appender, std:... | FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
if (pbegin == pend) return;
for (;;) {
const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(pbegin, pend, Char('}'), p))
return handler_.on_text(pbegin, pend);
++p;
if (p == pend || *p != '}')
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdx, %rsi
je 0xc52e1
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdx
subq %r15, %rdx
js 0xc52f9
movq %r15, %rdi
movl $0x7d, %esi
callq 0xca30
movq %rax, %r12
testq %rax, %rax
je 0xc52ce
leaq 0x1(%r12), %rdx
cmpq %rbx, %rdx
je 0xc52ed
cmpb $0x7... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
void fmt::v8::detail::vformat_to<char>(fmt::v8::detail::buffer<char>&, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<std::conditional<std::is_same<fmt::v8::type_identity<char>::type, char>::value, fmt::v8::appender, std::back_insert_iterator<fmt::v8::detail::buffer<fmt::v8::... | auto on_format_specs(int id, const Char* begin, const Char* end)
-> const Char* {
auto arg = get_arg(context, id);
if (arg.type() == type::custom_type) {
parse_context.advance_to(parse_context.begin() +
(begin - &*parse_context.begin()));
visit_format... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r12
movq %rdx, %r14
movl %esi, %edx
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xc5829
movl 0x10(%r13), %eax
cmpl $0xf, %eax
jne 0xc537b
movq 0x8(%r15), %rax
subq %rax, %r14
js 0xc5... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
char const* fmt::v8::detail::do_parse_arg_id<char, char const* fmt::v8::detail::parse_replacement_field<char, void fmt::v8::detail::vformat_to<char>(fmt::v8::detail::buffer<char>&, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<std::conditional<std::is_same<fmt::v8::type_iden... | FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) -> const Char* {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index =
parse_nonnegative_int(begin, end, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0xc592a
movq %rdx, %rbx
movq %rdi, %rsi
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xc5887
cmpb $0x30, %al
jne 0xc58d4
incq %rsi
movq %rsi, 0x8(%rsp)
xorl %eax, %eax
jmp 0xc58e6
cmpb $0x5f, %al
je 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
int fmt::v8::basic_format_args<fmt::v8::basic_format_context<fmt::v8::appender, char>>::get_id<char>(fmt::v8::basic_string_view<char>) const | auto get_id(basic_string_view<Char> name) const -> int {
if (!has_named_args()) return -1;
const auto& named_args =
(is_packed() ? values_[-1] : args_[-1].value_).named_args;
for (size_t i = 0; i < named_args.size; ++i) {
if (named_args.data[i].name == name) return named_args.data[i].id;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq (%rdi), %rdx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
btq $0x3e, %rdx
jae 0xc5a1f
movq %rsi, %r15
movq 0x8(%rdi), %rsi
xorl %ecx, %ecx
testq %rdx, %rdx
setns %cl
shll $0x4, %ecx
orq $-0x20, %rcx
movq 0x8(%rsi,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::parse_width<char, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&) | FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
using detail::auto_id;
struct width_adapter {
Handler& handler;
FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
FMT_CONSTEXPR void operator()(in... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
cmpq %rsi, %rdi
je 0xc5c93
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xc5bff
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xbe... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
char const* fmt::v8::detail::parse_precision<char, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&) | FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
using detail::auto_id;
struct precision_adapter {
Handler& handler;
FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
FMT_CONSTEXPR vo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rdi), %rax
movq %rax, 0x20(%rsp)
cmpq %rsi, %rax
je 0xc5cea
movsbl (%rax), %eax
jmp 0xc5cec
xorl %eax, %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0xc5d1a
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
int fmt::v8::detail::get_dynamic_spec<fmt::v8::detail::width_checker, fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender, char>>, fmt::v8::detail::error_handler>(fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender, char>>, fmt::v8::detail::error_handler) | FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
return static_cast<int>(value);
} | pushq %rax
movl 0x20(%rsp), %ecx
decl %ecx
cmpl $0xe, %ecx
ja 0xc5fdf
leaq 0x10(%rsp), %rax
leaq 0x354d0(%rip), %rdx # 0xfb474
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movslq (%rax), %rax
jmp 0xc5fc1
cmpq $0x0, 0x8(%rax)
js 0xc5fc6
movq (%rax), %rax
jmp 0xc5fd4
movq (%rax), %rax
testq %rax, %rax
jns 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
char const* fmt::v8::detail::do_parse_arg_id<char, char const* fmt::v8::detail::parse_precision<char, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&>(char const*, char const*, fmt::v8::detail::specs_checker<fmt::v8::detail::specs_handler<char>>&)::precision_adapter&>(char const*, char const*, fmt... | FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) -> const Char* {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index =
parse_nonnegative_int(begin, end, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, 0x28(%rsp)
cmpq %rsi, %rdi
je 0xc61ef
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rdx
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xc60fa
cmpb $0x30, %al
jne 0xc6176
incq %rdx
movq %rdx, 0x28(%rsp)
xorl %edx, %edx
jmp 0xc618a
cmpb $0x5f, %al
je ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/core.h |
int fmt::v8::detail::get_dynamic_spec<fmt::v8::detail::precision_checker, fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender, char>>, fmt::v8::detail::error_handler>(fmt::v8::basic_format_arg<fmt::v8::basic_format_context<fmt::v8::appender, char>>, fmt::v8::detail::error_handler) | FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg, ErrorHandler eh) -> int {
unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
return static_cast<int>(value);
} | pushq %rax
movl 0x20(%rsp), %ecx
decl %ecx
cmpl $0xe, %ecx
ja 0xc6272
leaq 0x10(%rsp), %rax
leaq 0x35279(%rip), %rdx # 0xfb4b0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movslq (%rax), %rax
jmp 0xc6254
cmpq $0x0, 0x8(%rax)
js 0xc6259
movq (%rax), %rax
jmp 0xc6267
movq (%rax), %rax
testq %rax, %rax
jns 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_int_noinline<char, fmt::v8::appender, unsigned long>(fmt::v8::appender, fmt::v8::detail::write_int_arg<unsigned long>, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::locale_ref) | FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char>& specs,
locale_ref loc) -> OutputIt {
return write_int(out, arg, specs, loc);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movzbl 0x8(%rcx), %r13d
cmpq $0xf, %r13
ja 0xc688a
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3522e(%rip), %rax # 0xfb4ec
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
testb $0... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned long>(fmt::v8::appender, fmt::v8::detail::write_int_arg<unsigned long>, fmt::v8::basic... | 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
movslq (%rsi), %rax
testq %rax, %rax
js 0xc69aa
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3534b(%rip), %rcx # 0xfbc34
movb (%rax,... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned long>(fmt::v8::appender, fmt::v8::detail::write_int_arg<unsigned long>, fmt::v8::basic... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc6a4b
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x35241(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned long>(fmt::v8::appender, fmt::v8::detail::write_int_arg<unsigned long>, fmt::v8::basic... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc6ddd
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x34eaf(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_int_localized<fmt::v8::appender, unsigned __int128, char>(fmt::v8::appender, unsigned __int128, unsigned int, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::digit_grouping<char> const&) | auto write_int_localized(OutputIt out, UInt value, unsigned prefix,
const basic_format_specs<Char>& specs,
const digit_grouping<Char>& grouping) -> OutputIt {
static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
int num_digits = count_digits(value);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r15
movq %r8, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl %ecx, 0xc(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xc015e
movl %eax, 0x8(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
m... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
unsigned __int128 fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int_localized<fmt::v8::appender, unsigned __int128, char>(fmt::v8::appender, unsigned __int128, unsigned int, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::digit_groupi... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
testq %rax, %rax
js 0xc7883
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r12
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3445b(%rip), %rcx # 0xfbc34
movb (%rax,%rcx),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned __int128>(fmt::v8::appender, fmt::v8::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 $0x28, %rsp
movslq (%rsi), %rax
testq %rax, %rax
js 0xc799b
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3435e(%rip), %rcx # 0xfbc34
movb (%rax,... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned __int128>(fmt::v8::appender, fmt::v8::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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc7a3c
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x34250(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned __int128>(fmt::v8::appender, fmt::v8::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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc7c48
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x34044(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)2, fmt::v8::appender, char, char fmt::v8::detail::write_int<fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write_int<char, fmt::v8::appender, unsigned __int128>(fmt::v8::appender, fmt::v8::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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc7e29
movq %r8, %r15
movq %rdi, %rsi
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x33e63(%rip), %rcx # 0xfbc34
movb (%rax,%rcx), %cl
movq %r14, %r12
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender>(fmt::v8::appender, char, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::locale_ref) | FMT_CONSTEXPR auto write(OutputIt out, Char value,
const basic_format_specs<Char>& specs,
locale_ref loc = {}) -> OutputIt {
return check_char_specs(specs)
? write_char(out, value, specs)
: write(out, static_cast<int>(value), specs, loc);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x6(%rsp), %rsi
movq %rdx, %rdi
callq 0xc800c
testb %al, %al
je 0xc7fc0
leaq 0x7(%rsp), %r8
movb %bpl, (%r8)
movl $0x1, %edx
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc1696
jmp 0xc80... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, float, 0>(fmt::v8::appender, float, fmt::v8::basic_format_specs<char>, fmt::v8::detail::locale_ref) | FMT_CONSTEXPR20 auto write(OutputIt out, T value,
basic_format_specs<Char> specs, locale_ref loc = {})
-> OutputIt {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (detail::signbit(v... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rcx, %r14
movaps %xmm0, 0x20(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, 0x8(%r15)
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0xc3c49
movdqa 0x20(%rsp), %xmm0
movq %rax, 0x8(%rsp)
movzwl 0x9(%r15),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender, double, 0>(fmt::v8::appender, double, fmt::v8::basic_format_specs<char>, fmt::v8::detail::locale_ref) | FMT_CONSTEXPR20 auto write(OutputIt out, T value,
basic_format_specs<Char> specs, locale_ref loc = {})
-> OutputIt {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (detail::signbit(v... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rcx, %r14
movaps %xmm0, 0x20(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, 0x8(%r15)
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0xc3c49
movdqa 0x20(%rsp), %xmm0
movq %rax, 0x8(%rsp)
movzwl 0x9(%r15),... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender>(fmt::v8::appender, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_specs<char> const&) | FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
const basic_format_specs<Char>& specs) -> OutputIt {
auto data = s.data();
auto size = s.size();
if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
size = code_point_index(s, to_unsigned(specs.precision));... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movslq 0x4(%rcx), %rax
cmpq %rdx, %rax
movq %rdx, %r15
cmovbq %rax, %r15
testq %rax, %rax
cmovsq %rdx, %r15
cmpl $0x0, (%rcx)
je 0xc8650
movq %rsp, %r13
movq $0x0, (%r13)
movq %r12, %rdi
movq %r15, %r... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::appender fmt::v8::detail::write_padded<(fmt::v8::align::type)1, fmt::v8::appender, char, fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender>(fmt::v8::appender, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_specs<char> const&)::'lambda'(fmt::v8::appender)>(fmt::v8::appender, fmt::v8::bas... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rsi), %rax
testq %rax, %rax
js 0xc8711
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x3358b(%rip), %rcx # 0xfbc39
movb (%rax,%rcx), %cl
movq %r15, %r13
s... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
void fmt::v8::detail::for_each_codepoint<fmt::v8::detail::compute_width(fmt::v8::basic_string_view<char>)::count_code_points>(fmt::v8::basic_string_view<char>, fmt::v8::detail::compute_width(fmt::v8::basic_string_view<char>)::count_code_points) | FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
auto decode = [f](const char* buf_ptr, const char* ptr) {
auto cp = uint32_t();
auto error = 0;
auto end = utf8_decode(buf_ptr, &cp, &error);
bool result = f(error ? invalid_code_point : cp,
string_view(ptr, to_unsigned(en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movq %rdi, %r14
cmpq $0x4, %rsi
jb 0xc8783
leaq (%rbx,%r15), %rbp
addq $-0x3, %rbp
leaq 0x10(%rsp), %r13
xorl %r14d, %r14d
movq %rbx, %rax
movq %rax, %r12
cmpq %rbp, %rax
jae 0xc877b
... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/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.