name string | code string | asm string | file string |
|---|---|---|---|
fmt::v9::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v9::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&) | FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
alloc_ = std::move(other.alloc_);
T* data = other.data();
size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
detail::copy_str<T>(other.store_, other.store_ + size,
... | movq %rsi, %rax
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rsi
movq 0x18(%rax), %rdx
leaq 0x20(%rax), %rcx
cmpq %rcx, %r8
je 0x1a3bb
movq %r8, 0x8(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x8(%rax)
addq $0x10, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x1a130
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x18(%... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::bigint::multiply<unsigned __int128, 0>(unsigned __int128) | FMT_CONSTEXPR20 void multiply(UInt value) {
using half_uint =
conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
const int shift = num_bits<half_uint>() - bigit_bits;
const UInt lower = static_cast<half_uint>(value);
const UInt upper = value >> num_bits<half_uint>();
UI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rdi, %rbx
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %r10
movq %rdx, %r11
shrq $0x20, %r11
shlq $0x20, %rcx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r14, %r10
je 0x1a48b
movl (%r9,%r14,4), %r8d
movq %r8, %rax... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::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 %rax
movl %esi, %eax
andl $0x0, 0x4(%rsp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rsi
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x1a530
movl (%rcx,%r8,4), %r9d
imulq %rax, %r9
movl %edx, %edx
addq %r9, %rdx
movl %edx, (%rcx,%r8,4)
shrq $0x20, %rdx
movl %edx, 0x4(%rsp)
incq %r8
jmp 0x1a50d
testl %edx, %edx
... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::align(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 void align(const bigint& other) {
int exp_difference = exp_ - other.exp_;
if (exp_difference <= 0) return;
int num_bigits = static_cast<int>(bigits_.size());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0xa8(%rdi), %r14d
subl 0xa8(%rsi), %r14d
jle 0x1a5b3
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
leal (%r14,%r15), %edi
callq 0x156df
movl %eax, %esi
movq %rbx, %rdi
callq 0x1a130
movl %r15d, %eax
decl %eax
leal (%r15,%r14), %ecx
decl %ecx
movq 0x8(%rbx), %rdi
movslq %e... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::subtract_aligned(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) {
FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
FMT_ASSERT(compare(*this, other) >= 0, "");
bigit borrow = 0;
int i = other.exp_ - exp_;
for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
subtract_bigits(i, other.big... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xa8(%rsi), %eax
cmpl 0xa8(%rdi), %eax
jl 0x1a666
movq %rsi, %r14
movq %rdi, %rbx
callq 0x19f99
testl %eax, %eax
js 0x1a67e
leaq 0x4(%rsp), %rax
andl $0x0, (%rax)
movl 0xa8(%r14), %r13d
subl 0xa8(%rbx), %r13d
movq 0x10(%r14), %rbp
xorl %r... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::subtract_bigits(int, unsigned int, unsigned int&) | FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) {
auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
(*this)[index] = static_cast<bigit>(result);
borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
callq 0x156df
movq 0x8(%r15), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %r12d
movl %ebp, %eax
movl (%rbx), %ecx
addq %rax, %rcx
subq %rcx, %r12
movl %r14d, %edi
callq 0x156df
movq 0x8(%... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref) | FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
const basic_format_specs<Char>& specs,
float_specs fspecs, locale_ref loc)
-> OutputIt {
auto significand = f.significand;
int significand_size = get_significand_size(f);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rcx, 0x60(%rsp)
movq (%rsi), %rax
movq %rax, 0x58(%rsp)
movq %rax, 0x48(%rsp)
movq %rsi, 0x28(%rsp)
movl 0x8(%rsi), %ebp
movl %ebp, 0x14(%rsp)
movb $0x30, 0... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::big_decimal_fp fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::big_decimal_fp, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::big_decimal_fp const&, fm... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x7273(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::basic_string_view<char>::compare(fmt::v9::basic_string_view<char>) const | FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int {
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);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rdx
cmpq %rbx, %rdx
cmovaeq %rbx, %rdx
callq 0x1c0a8
testl %eax, %eax
jne 0x1c0a0
movq 0x8(%r14), %rcx
xorl %edx, %edx
cmpq %rbx, %rcx
movl $0x0, %eax
sbbl %eax, %eax
orl $0x1, %eax
cmpq %rbx, %rcx
cmovel %edx, %eax
addq... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
fmt::v9::presentation_type fmt::v9::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 0x1c0e7
leaq 0x5115(%rip), %rcx # 0x211f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x7, %al
retq
leal -0x3f(%rdi), %eax
cmpl $0x8, %eax
ja 0x1c102
leaq 0x50d6(%rip), %rcx # 0x211cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x12, %... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
char const* fmt::v9::detail::parse_align<char, fmt::v9::detail::specs_checker<fmt::v9::detail::specs_handler<char>>&>(char const*, char const*, fmt::v9::detail::specs_checker<fmt::v9::detail::specs_handler<char>>&) | FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
Handler&& handler) -> const Char* {
FMT_ASSERT(begin != end, "");
auto align = align::none;
auto p = begin + code_point_length(begin);
if (end - p <= 0) p = begin;
for (;;) {
switch (to_ascii(*p)) {
case ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x1c1e8
movq %rdx, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movl %eax, %ecx
shrl $0x3, %ecx
leaq 0x69a0(%rip), %rdx # 0x22aff
movzbl (%rcx,%rdx), %ecx
cmpb $0x1, %cl
adcl $0x0, %ecx
movsbq %cl, %r15
addq %rdi, %r15
subq %r15, %rsi
testq %rsi... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
int fmt::v9::detail::count_digits<1, unsigned long>(unsigned long) | FMT_CONSTEXPR auto count_digits(UInt n) -> int {
#ifdef FMT_BUILTIN_CLZ
if (!is_constant_evaluated() && num_bits<UInt>() == 32)
return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
#endif
// Lambda avoids unreachable code warnings from NVHPC.
return [](UInt m) {
int num_digits = 0;
... | pushq %rax
movq %rdi, %rsi
leaq 0x7(%rsp), %rdi
callq 0x1d0e6
popq %rcx
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned long>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned long>, fmt::v9::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 %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x5010(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned long>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned long>, fmt::v9::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 %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x4f02(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::format_uint<1u, char, fmt::v9::appender, unsigned long>(fmt::v9::appender, unsigned long, int, bool) | inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
-> It {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %edi
callq 0x156df
movl %eax, %esi
movq %rbx, %rdi
callq 0x1488c
movzbl %r15b, %ecx
testq %rax, %rax
je 0x1d156
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1d189
jmp 0x1d1... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char* fmt::v9::detail::format_uint<1u, char, unsigned long>(char*, unsigned long, int, bool) | FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) -> Char* {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = static_cast<unsigned>(value & ((1 << ... | movslq %edx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
movq %rsi, %rdx
movl %esi, %edi
andb $0x1, %dil
orb $0x30, %dil
movb %dil, (%rcx)
shrq %rdx
decq %rcx
cmpq $0x1, %rsi
movq %rdx, %rsi
ja 0x1d199
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned long>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned long>, fmt::v9::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 %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x4d44(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::format_uint<3u, char, fmt::v9::appender, unsigned long>(fmt::v9::appender, unsigned long, int, bool) | inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
-> It {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %edi
callq 0x156df
movl %eax, %esi
movq %rbx, %rdi
callq 0x1488c
movzbl %r15b, %ecx
testq %rax, %rax
je 0x1d316
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1d349
jmp 0x1d3... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char* fmt::v9::detail::format_uint<3u, char, unsigned long>(char*, unsigned long, int, bool) | FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) -> Char* {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = static_cast<unsigned>(value & ((1 << ... | movslq %edx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
movq %rsi, %rdx
movl %esi, %edi
andb $0x7, %dil
orb $0x30, %dil
movb %dil, (%rcx)
shrq $0x3, %rdx
decq %rcx
cmpq $0x7, %rsi
movq %rdx, %rsi
ja 0x1d359
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_int_noinline<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref) | FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
OutputIt out, write_int_arg<T> arg, const basic_format_specs<Char>& specs,
locale_ref loc) -> OutputIt {
return write_int(out, arg, specs, loc);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0xc0(%rsp), %r12
movq 0xc8(%rsp), %r13
movl 0xd0(%rsp), %ebx
movq %rdi, 0x28(%rsp)
movzbl 0x8(%rsi), %eax
cmpq $0xf, %rax
ja 0x1d85d
movq %rdx, %r9
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3e59(%rip), %rcx # 0x21308
movslq (%rcx,... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
int fmt::v9::detail::count_digits<4, unsigned __int128>(unsigned __int128) | FMT_CONSTEXPR auto count_digits(UInt n) -> int {
#ifdef FMT_BUILTIN_CLZ
if (!is_constant_evaluated() && num_bits<UInt>() == 32)
return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
#endif
// Lambda avoids unreachable code warnings from NVHPC.
return [](UInt m) {
int num_digits = 0;
... | pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x7(%rsp), %rdi
callq 0x1dba2
popq %rcx
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
int fmt::v9::detail::count_digits<3, unsigned __int128>(unsigned __int128) | FMT_CONSTEXPR auto count_digits(UInt n) -> int {
#ifdef FMT_BUILTIN_CLZ
if (!is_constant_evaluated() && num_bits<UInt>() == 32)
return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
#endif
// Lambda avoids unreachable code warnings from NVHPC.
return [](UInt m) {
int num_digits = 0;
... | pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x7(%rsp), %rdi
callq 0x1df8e
popq %rcx
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_int_localized<fmt::v9::appender, unsigned __int128, char>(fmt::v9::appender, unsigned __int128, unsigned int, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::digit_grouping<char> const&) | auto write_int_localized(OutputIt out, UInt value, unsigned prefix,
const basic_format_specs<Char>& specs,
const digit_grouping<Char>& grouping) -> OutputIt {
static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
int num_digits = count_digits(value);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
leaq 0x4(%rsp), %rax
movl %ecx, (%rax)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x14e7a
movl %eax, %ebx
movq %rsp, %rax
movl %ebx, (%rax)
lea... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
unsigned __int128 fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int_localized<fmt::v9::appender, unsigned __int128, char>(fmt::v9::appender, unsigned __int128, unsigned int, fmt::v9::basic_format_specs<char> const&, fmt::v9::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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x4550(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x4446(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::format_uint<4u, char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, unsigned __int128, int, bool) | inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
-> It {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %edi
callq 0x156df
movl %eax, %esi
movq %rbx, %rdi
callq 0x1488c
movzbl %r12b, %r8d
testq %rax, %rax
je 0x1dc37
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char* fmt::v9::detail::format_uint<4u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) -> Char* {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = static_cast<unsigned>(value & ((1 << ... | movslq %ecx, %r9
leaq 0x3b06(%rip), %rax # 0x2177f
leaq 0x3b10(%rip), %rcx # 0x21790
testl %r8d, %r8d
cmovneq %rax, %rcx
leaq (%rdi,%r9), %rax
addq %r9, %rdi
decq %rdi
pushq $0xf
popq %r8
movq %rdx, %r9
movl %esi, %r10d
andl $0xf, %r10d
movb (%rcx,%r10), %r10b
movb %r10b, (%rdi)
movq %rdx, %r10
shldq $0x3c, %... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x4231(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::format_uint<1u, char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, unsigned __int128, int, bool) | inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
-> It {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %edi
callq 0x156df
movl %eax, %esi
movq %rbx, %rdi
callq 0x1488c
movzbl %r12b, %r8d
testq %rax, %rax
je 0x1de22
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char* fmt::v9::detail::format_uint<1u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) -> Char* {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = static_cast<unsigned>(value & ((1 << ... | movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
pushq $0x1
popq %rdi
movq %rdx, %r8
movl %esi, %r9d
andb $0x1, %r9b
orb $0x30, %r9b
movb %r9b, (%rcx)
movq %rdx, %r9
shldq $0x3f, %rsi, %r9
shrq %r8
decq %rcx
cmpq %rsi, %rdi
movl $0x0, %esi
sbbq %rdx, %rsi
movq %r9, %rsi
movq %r8, %rdx
jb 0x1de70
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl (%rsi), %edi
callq 0x156df
movl %eax, %eax
xorl %r14d, %r14d
subq %r13, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rbx), %eax
andl $0xf, %eax
leaq 0x405a(%rip), %rcx # 0x21f30
movb (%rax,%rcx), %cl
m... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::format_uint<3u, char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, unsigned __int128, int, bool) | inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
-> It {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %edi
callq 0x156df
movl %eax, %esi
movq %rbx, %rdi
callq 0x1488c
movzbl %r12b, %r8d
testq %rax, %rax
je 0x1e021
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
char* fmt::v9::detail::format_uint<3u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) -> Char* {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = static_cast<unsigned>(value & ((1 << ... | movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
pushq $0x7
popq %rdi
movq %rdx, %r8
movl %esi, %r9d
andb $0x7, %r9b
orb $0x30, %r9b
movb %r9b, (%rcx)
movq %rdx, %r9
shldq $0x3d, %rsi, %r9
shrq $0x3, %r8
decq %rcx
cmpq %rsi, %rdi
movl $0x0, %esi
sbbq %rdx, %rsi
movq %r9, %rsi
movq %r8, %rdx
jb 0x1e06c... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender>(fmt::v9::appender, char, fmt::v9::basic_format_specs<char> const&, fmt::v9::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, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x7(%rsp), %rsi
movq %rdx, %rdi
callq 0x1e20a
testb %al, %al
je 0x1e1be
movsbl %bpl, %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1545a
jmp 0x1e1ff
movsbl %bpl, %eax
testb %al, %al
js 0x1e1e0
movz... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
bool fmt::v9::detail::check_char_specs<char, fmt::v9::detail::error_handler>(fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::error_handler&&) | FMT_CONSTEXPR auto check_char_specs(const basic_format_specs<Char>& specs,
ErrorHandler&& eh = {}) -> bool {
if (specs.type != presentation_type::none &&
specs.type != presentation_type::chr &&
specs.type != presentation_type::debug) {
check_int_type_spec(specs.type... | pushq %rax
movzbl 0x8(%rdi), %eax
cmpl $0x12, %eax
ja 0x1e243
movl $0x48001, %ecx # imm = 0x48001
btl %eax, %ecx
jae 0x1e243
movzwl 0x9(%rdi), %ecx
movl %ecx, %eax
andl $0xf, %eax
cmpw $0x4, %ax
je 0x1e237
movb $0x1, %al
andl $0xf0, %ecx
je 0x1e24d
leaq 0x3896(%rip), %rdi # 0x21ad4
callq 0x146cf
movzbl %a... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, float, 0>(fmt::v9::appender, float, fmt::v9::basic_format_specs<char>, fmt::v9::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 %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
movq %rcx, %r14
movaps %xmm0, 0x20(%rsp)
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x19008
movdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax, ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
int fmt::v9::detail::snprintf_float<double>(double, int, fmt::v9::detail::float_specs, fmt::v9::detail::buffer<char>&) | auto snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) -> int {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
FMT_ASSERT(specs.format == float_format::hex, "");
static_assert(!s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rdx), %rax
cmpq 0x10(%rdx), %rax
jbe 0x1e5f5
movabsq $0xff00000000, %rax # imm = 0xFF00000000
andq %rsi, %rax
movabsq $0x300000000, %rcx # imm = 0x300000000
cmpq %rcx, %rax
jne 0x1e60d
movq %rd... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, unsigned long, 0>(fmt::v9::appender, unsigned 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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14c68
movl %eax, %ebp
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x1488c
testq %rax, %rax
je 0x1ebb0
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x14bac
jmp 0x1ebc0
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x14c... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::basic_fp<unsigned long long> fmt::v9::detail::normalize<0, unsigned long long>(fmt::v9::detail::basic_fp<unsigned long long>) | FMT_CONSTEXPR basic_fp<F> normalize(basic_fp<F> value) {
// Handle subnormals.
const auto implicit_bit = F(1) << num_significand_bits<double>();
const auto shifted_implicit_bit = implicit_bit << SHIFT;
while ((value.f & shifted_implicit_bit) == 0) {
value.f <<= 1;
--value.e;
}
// Subtract 1 to accou... | movl %esi, %edx
movq %rdi, %rax
addl $-0xb, %edx
btq $0x34, %rax
jb 0x1ebde
addq %rax, %rax
decl %edx
jmp 0x1ebd0
shlq $0xb, %rax
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::get_cached_power(int, int&) | FMT_CONSTEXPR inline fp get_cached_power(int min_exponent,
int& pow10_exponent) {
const int shift = 32;
// log10(2) = 0x0.4d104d427de7fbcc...
const int64_t significand = 0x4d104d427de7fbcc;
int index = static_cast<int>(
((min_exponent + fp::num_significand_bits - 1... | addl $0x3f, %edi
movslq %edi, %rax
imulq $0x4d104d42, %rax, %rcx # imm = 0x4D104D42
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq %rcx, %rax
shrq $0x20, %rax
addl $0x15b, %eax # imm = 0x15B
pushq $0x8
popq %rcx
cltd
idivl %ecx
leal -0x154(,%rax,8), %ecx
movl %ecx, (%rsi)
movslq %eax, %rcx
leaq 0x3f06(... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
bool fmt::v9::detail::basic_fp<unsigned __int128>::assign<double, 0>(double) | FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
#ifdef __cpp_lib_bit_cast
if (is_constant_evaluated()) return std::bit_cast<To>(from);
#endif
auto to = To();
// The cast suppresses a bogus -Wclass-memaccess on GCC.
std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
return to;
} | movq %xmm0, %rax
movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
andq %rax, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
andq %rax, %rdx
movq %rdx, %rax
shrq $0x34, %rax
movq %rcx, %rsi
btsq $0x34, %rsi
addl $0xfffffbcd, %eax # imm = 0xFFFFFBCD
testq %rdx, %rdx
cmoveq %rcx, %rsi
movl ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::get_round_direction(unsigned long, unsigned long, unsigned long) | get_round_direction(uint64_t divisor,
uint64_t remainder,
uint64_t error) {
FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow.
FMT_ASSERT(error < divisor, ""); // divisor ... | pushq %rax
movq %rdi, %rax
subq %rsi, %rax
jbe 0x1ed2c
movq %rdi, %rcx
subq %rdx, %rcx
jbe 0x1ed44
cmpq %rdx, %rcx
jbe 0x1ed5c
cmpq %rsi, %rax
jb 0x1ed12
leaq (%rdx,%rdx), %rax
movq %rdi, %r8
subq %rsi, %r8
subq %rsi, %r8
cmpq %r8, %rax
jbe 0x1ed23
subq %rdx, %rsi
jb 0x1ed1f
subq %rsi, %rdi
cmpq %rdi, %rsi
jae 0x1ed27
... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, double, 0>(fmt::v9::appender, double, fmt::v9::basic_format_specs<char>, fmt::v9::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 %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
movq %rcx, %r14
movaps %xmm0, 0x20(%rsp)
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x19008
movdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax, ... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender>(fmt::v9::appender, char const*, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref) | FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
const basic_format_specs<Char>& specs, locale_ref)
-> OutputIt {
return check_cstring_type_spec(specs.type)
? write(out, basic_string_view<Char>(s), specs, {})
: write_ptr<Char>(out, bit_cast<uintptr_t>(s), &s... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x8(%rdx), %edi
leaq 0xf(%rsp), %rsi
callq 0x1f146
testb %al, %al
je 0x1f12e
movq %r14, %rdi
callq 0x12130
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x1f173
jmp 0x1f13c
mo... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
bool fmt::v9::detail::check_cstring_type_spec<fmt::v9::detail::error_handler>(fmt::v9::presentation_type, fmt::v9::detail::error_handler&&) | FMT_CONSTEXPR auto check_cstring_type_spec(presentation_type type,
ErrorHandler&& eh = {}) -> bool {
if (type == presentation_type::none || type == presentation_type::string ||
type == presentation_type::debug)
return true;
if (type != presentation_type::pointer)... | cmpl $0x12, %edi
ja 0x1f166
movl $0x70001, %eax # imm = 0x70001
btl %edi, %eax
jae 0x1f166
testb $-0x11, %dil
sete %cl
cmpb $0x12, %dil
sete %al
orb %cl, %al
retq
pushq %rax
leaq 0x25d0(%rip), %rdi # 0x2173e
callq 0x146cf
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl 0x4(%rcx), %edi
movq %rdx, %r13
testl %edi, %edi
js 0x1f21a
callq 0x156df
movl %eax, %eax
movq %r12, %r13
cmpq %r12, %rax
jae 0x1f21a
movl 0x4(%rbx), %edi
callq 0x156df... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::counting_iterator fmt::v9::detail::write_escaped_string<char, fmt::v9::detail::counting_iterator>(fmt::v9::detail::counting_iterator, fmt::v9::basic_string_view<char>) | auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
-> OutputIt {
*out++ = static_cast<Char>('"');
auto begin = str.begin(), end = str.end();
do {
auto escape = find_escape(begin, end);
out = copy_str<Char>(begin, escape.begin, out);
begin = escape.end;
if (!begin) break;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
incq %rbx
addq %rsi, %r14
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f3b9
subq %r15, %rbx
addq (%rsp), %rbx
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x1f2fb
movq %rbx, %rdi
movq %r1... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::for_each_codepoint<fmt::v9::detail::find_escape(char const*, char const*)::'lambda'(unsigned int, fmt::v9::basic_string_view<char>)>(fmt::v9::basic_string_view<char>, fmt::v9::detail::find_escape(char const*, char const*)::'lambda'(unsigned int, fmt::v9::basic_string_view<char>)) | 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, error ? 1 : to... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, (%rsp)
movq %rdi, %r14
cmpq $0x4, %rsi
jb 0x1f4fc
leaq (%rbx,%r15), %r13
addq $-0x3, %r13
movq %rsp, %r12
movq %rbx, %r14
cmpq %r13, %r14
jae 0x1f4fc
movq %r12, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::utf8_decode(char const*, unsigned int*, int*) | FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)
-> const char* {
constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
constexpr const int shiftc[] = {0, 18, 12, 6, 0};
constexpr const int shifte[] = {0, 6, 4... | movzbl (%rdi), %ecx
movl %ecx, %eax
shrl $0x3, %eax
leaq 0x3504(%rip), %r8 # 0x22aff
movsbq (%rax,%r8), %r8
movl $0x80ff0000, %r9d # imm = 0x80FF0000
btl %eax, %r9d
movq %rdi, %rax
adcq %r8, %rax
leaq 0x2929(%rip), %r9 # 0x21f40
andl (%r9,%r8,4), %ecx
shll $0x12, %ecx
movl %ecx, (%rsi)
movzbl 0x1(%rdi... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::counting_iterator fmt::v9::detail::write_codepoint<2ul, char, fmt::v9::detail::counting_iterator>(fmt::v9::detail::counting_iterator, char, unsigned int) | auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
*out++ = static_cast<Char>('\\');
*out++ = static_cast<Char>(prefix);
Char buf[width];
fill_n(buf, width, static_cast<Char>('0'));
format_uint<4>(buf, cp, width);
return copy_str<Char>(buf, buf + width, out);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe(%rsp), %rdi
movw $0x3030, (%rdi) # imm = 0x3030
pushq $0x2
popq %rax
movl %edx, %esi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x15d70
addq $0x4, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::for_each_codepoint<fmt::v9::detail::compute_width(fmt::v9::basic_string_view<char>)::count_code_points>(fmt::v9::basic_string_view<char>, fmt::v9::detail::compute_width(fmt::v9::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, error ? 1 : to... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, (%rsp)
movq %rdi, %r14
cmpq $0x4, %rsi
jb 0x1f7f7
leaq (%rbx,%r15), %r13
addq $-0x3, %r13
movq %rsp, %r12
movq %rbx, %r14
cmpq %r13, %r14
jae 0x1f7f7
movq %r12, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::for_each_codepoint<fmt::v9::detail::compute_width(fmt::v9::basic_string_view<char>)::count_code_points>(fmt::v9::basic_string_view<char>, fmt::v9::detail::compute_width(fmt::v9::basic_string_view<char>)::count_code_points)::'lambda'(char const*, char const*)::operator()(char const*, char const*) c... | 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, error ? 1 : to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq %rsp, %r13
andl $0x0, (%r13)
movq %rbx, %rdi
movq %r13, %rdx
callq 0x1f5ec
movq %rax, %r15
xorl %eax, %eax
cmpl %eax, (%r13)
je 0x1f8a4
pushq $0x1
popq... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::compute_width(fmt::v9::basic_string_view<char>)::count_code_points::operator()(unsigned int, fmt::v9::basic_string_view<char>) const | FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool {
*count += detail::to_unsigned(
1 +
(cp >= 0x1100 &&
(cp <= 0x115f || // Hangul Jamo init. consonants
cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET
cp == 0x232a || // RIGHT-POINTING AN... | pushq %rbx
movq %rdi, %rbx
cmpl $0x1100, %esi # imm = 0x1100
jb 0x1f9b5
cmpl $0x1160, %esi # imm = 0x1160
setb %al
leal -0x2329(%rsi), %ecx
cmpl $0x2, %ecx
setb %cl
orb %al, %cl
pushq $0x2
popq %rdi
jne 0x1f9b8
leal -0x2e80(%rsi), %eax
cmpl $0x7650, %eax # imm = 0x7650
setb %al
cmpl $0x303... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_escaped_string<char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>) | auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
-> OutputIt {
*out++ = static_cast<Char>('"');
auto begin = str.begin(), end = str.end();
do {
auto escape = find_escape(begin, end);
out = copy_str<Char>(begin, escape.begin, out);
begin = escape.end;
if (!begin) break;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r15
movb $0x22, (%r15)
movq %r15, %rsi
callq 0x149d2
addq %r12, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1f3b9
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x14a28
movq... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/format.h |
Catch::BinaryExpr<int const&, int const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1fbd3
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1fbd3
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14,... | /rezalas[P]riftshadow/tests/catch.hpp |
Catch::BinaryExpr<int const&, int const&> const Catch::ExprLhs<int const&>::operator!=<int>(int const&) | auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movl (%r12), %ebp
movl (%rdx), %r13d
leaq 0x1f2f(%rip), %rsi # 0x21c66
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x12110
cmpl %r13d, %ebp
movb $0x1, 0x8(%r14)
setne 0x9(%r14)
movups... | /rezalas[P]riftshadow/tests/catch.hpp |
Catch::BinaryExpr<int* const&, std::nullptr_t const&> const Catch::ExprLhs<int* const&>::operator==<std::nullptr_t>(std::nullptr_t const&) | auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movq (%r12), %r13
leaq 0x1d04(%rip), %rsi # 0x21b0f
movq %rsp, %r15
movq %r15, %rdi
callq 0x12110
testq %r13, %r13
movb $0x1, 0x8(%r14)
sete 0x9(%r14)
movups (%r15), %xmm0
leaq 0xaeea(%rip), %r... | /rezalas[P]riftshadow/tests/catch.hpp |
Catch::BinaryExpr<int* const&, long const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1ff09
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1fe4f
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14,... | /rezalas[P]riftshadow/tests/catch.hpp |
Catch::BinaryExpr<int* const&, std::nullptr_t const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1ff09
movq 0x18(%r15), %r14
movq 0x20(%r15), %r15
movq %rsp, %rdi
xorl %esi, %esi
callq 0x12330
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq... | /rezalas[P]riftshadow/tests/catch.hpp |
make_timelapse(std::vector<cv::Mat, std::allocator<cv::Mat>>, arguments) | void make_timelapse(vector<cv::Mat> image_list, arguments args)
{
cout<< color::blue << " Timelapse in progress "<<color::reset<<endl;
int codec = VideoWriter::fourcc('H', '2', '6', '4');
int h = 0, w = 0;
Size S = image_list[0].size();
VideoWriter outputVideo;
outputVideo.open(args.output_file_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x42ede(%rip), %rdi # 0x4ef90
leaq 0x43577(%rip), %rsi # 0x4f630
callq 0x92d0
leaq 0x2c145(%rip), %rsi # 0x3820a
movq %rax, %rdi
callq 0x9930
leaq 0x435bc(%rip), %rsi # 0x4f690
movq %r... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/utils/driver.hpp |
apply_filter(std::vector<cv::Mat, std::allocator<cv::Mat>>&, arguments, char**, int) | void apply_filter(std::vector<cv::Mat> &image_list, arguments args, char *argv[], int argc) {
std::cout << color::blue << "Optimizing Parameters :" << color::reset << std::endl;
apply_brightness(image_list, args.brightness_value);
apply_contrast(image_list, args.contrast_value);
apply_saturation(image_l... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x425cd(%rip), %rdi # 0x4ef90
leaq 0x42c66(%rip), %rsi # 0x4f630
callq 0x92d0
leaq 0x2b8e2(%rip), %rsi # 0x382b8
movq %rax, %rdi
callq 0x9930
leaq 0x42cab(%rip), %rsi # 0x4f690
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
callq 0x9200... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/filter/filter.hpp |
main | int main(int argc, char *argv[])
{
// CLI logic
arguments args;
CLI::App app{"CLI to create timelapse video"};
// CLI options
app.add_option("-s,--source", args.source_dir, "source directory containing frames")->required();
app.add_option("-o, --output", args.output_file_name, "output file name [defau... | pushq %rbp
pushq %rbx
subq $0x7c8, %rsp # imm = 0x7C8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x330(%rsp), %rdi
callq 0xeace
leaq 0x2b86c(%rip), %rsi # 0x382d0
leaq 0x310(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xd310
leaq 0x2c5da(%rip), %rsi # 0x39057
leaq 0x2f0(%rsp), %rdi
movq %rsp, %rdx
callq 0xd310... | /GFG-CLUB-KIIT[P]TimeLapse/src/main.cpp |
CLI::detail::ExistingDirectoryValidator::ExistingDirectoryValidator() | ExistingDirectoryValidator() : Validator("DIR") {
func_ = [](std::string &filename) {
auto path_result = check_path(filename.c_str());
if(path_result == path_type::nonexistent) {
return "Directory does not exist: " + filename;
}
if(path_result == p... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x2d23e(%rip), %rsi # 0x3a601
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0xd310
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11b30
leaq 0x8(%rsp), %rdi
callq 0x9b38
addq $0x20, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x12036
addq $0... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::ConfigBase::to_config(CLI::App const*, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | inline std::string
ConfigBase::to_config(const App *app, bool default_also, bool write_description, std::string prefix) const {
std::stringstream out;
std::string commentLead;
commentLead.push_back(commentChar);
commentLead.push_back(' ');
std::vector<std::string> groups = app->get_groups();
bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq %r9, 0x18(%rsp)
movl %r8d, 0x8(%rsp)
movl %ecx, 0x2c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d0(%rsp), %rdi
callq 0x9610
leaq 0xc0(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::App(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | explicit App(std::string app_description = "", std::string app_name = "")
: App(app_description, app_name, nullptr) {
set_help_flag("-h,--help", "Print this help message and exit");
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x96e0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x96e0
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1697e
leaq 0x48(%rsp), %rdi
callq 0x9b38
leaq 0x68(%rsp), %rdi
callq 0x9b38
lea... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::ConfigBase::from_config(std::istream&) const | inline std::vector<ConfigItem> ConfigBase::from_config(std::istream &input) const {
std::string line;
std::string section = "default";
std::vector<ConfigItem> output;
bool defaultArray = (arrayStart == '\0' || arrayStart == ' ') && arrayStart == arrayEnd;
char aStart = (defaultArray) ? '[' : arrayS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, 0xc0(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xd8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x29a58(%rip), %rsi # 0x38ffe
leaq 0x78(%rsp), %rdi
leaq 0x30(%... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Formatter::make_subcommand[abi:cxx11](CLI::App const*) const | inline std::string Formatter::make_subcommand(const App *sub) const {
std::stringstream out;
detail::format_help(out, sub->get_name(), sub->get_description(), column_width_);
return out.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x9610
leaq 0x8(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x96e0
addq $0x28, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x96e0
leaq 0x58(%rsp), %rdi
movq 0x8(%r14), ... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Formatter::make_usage(CLI::App const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | inline std::string Formatter::make_usage(const App *app, std::string name) const {
std::stringstream out;
out << get_label("Usage") << ":" << (name.empty() ? "" : " ") << name;
std::vector<std::string> groups = app->get_groups();
// Print an Options badge if any options exist
std::vector<const Op... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x150(%rsp), %rdi
callq 0x9610
leaq 0x28420(%rip), %rsi # 0x3916d
leaq 0xf0(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xd310
leaq 0x10(%rsp)... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Formatter::make_option_opts[abi:cxx11](CLI::Option const*) const | inline std::string Formatter::make_option_opts(const Option *opt) const {
std::stringstream out;
if(opt->get_type_size() != 0) {
if(!opt->get_type_name().empty())
out << " " << get_label(opt->get_type_name());
if(!opt->get_default_str().empty())
out << "=" << opt->get_de... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdx, %rbp
movq %rsi, 0x38(%rsp)
movq %rdi, %r15
leaq 0x110(%rsp), %rdi
callq 0x9610
cmpl $0x0, 0x14c(%rbp)
je 0x1155c
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x20848
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi),... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::NonNegativeNumber::NonNegativeNumber()::'lambda'(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | NonNegativeNumber() : Validator("NONNEGATIVE") {
func_ = [](std::string &number_str) {
double number;
if(!detail::lexical_cast(number_str, number)) {
return std::string("Failed parsing number: (") + number_str + ')';
}
if(number < 0) {
... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rsi
movq %rdx, %rdi
callq 0x129c1
testb %al, %al
je 0x12bb8
xorpd %xmm0, %xmm0
ucomisd 0x50(%rsp), %xmm0
jbe 0x12c06
leaq 0x25bc7(%rip), %rsi # 0x3874c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd310
leaq 0x30(%rsp), %r... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Validator::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | std::string operator()(std::string &str) const {
std::string retstring;
if(active_) {
if(non_modifying_) {
std::string value = str;
retstring = func_(value);
} else {
retstring = func_(str);
}
}
return re... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpb $0x1, 0x64(%rsi)
jne 0x1424e
movq %rsi, %r14
cmpb $0x1, 0x65(%rsi)
jne 0x14225
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x96e0
addq $0x20, %r14
leaq 0x28(%rsp), %rdi
leaq 0x8(... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Option::get_flag_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | std::string get_flag_value(const std::string &name, std::string input_value) const {
static const std::string trueString{"true"};
static const std::string falseString{"false"};
static const std::string emptyString{"{}"};
// check for disable flag override_
if(disable_flag_overrid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movb 0x3b6c9(%rip), %al # 0x4fa30
testb %al, %al
je 0x145d9
movb 0x3b6e3(%rip), %al # 0x4fa58
testb %al, %al
je 0x14630
movb 0x3b6fd(%rip), %al # 0x4fa80
test... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::remove_underscore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline std::string remove_underscore(std::string str) {
str.erase(std::remove(std::begin(str), std::end(str), '_'), std::end(str));
return str;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
addq %rdi, %rsi
leaq 0x7(%rsp), %rdx
movb $0x5f, (%rdx)
callq 0x14c47
movq (%rbx), %rdx
addq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9900
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9190
movq %r14, %rax
a... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Error::Error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::ExitCodes) | Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
callq 0x96e0
movq %rsp, %rdi
movq %r15, %rsi
callq 0x96e0
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x158e2
movq %rsp, %rdi
callq 0x9b38
leaq 0x20(%rsp), %rdi
callq 0... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::_add_flag_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> con... | Option *_add_flag_internal(std::string flag_name, CLI::callback_t fun, std::string flag_description) {
Option *opt;
if(detail::has_default_flag_values(flag_name)) {
// check for default values and if it has them
auto flag_defaults = detail::get_default_flag_values(flag_name);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x17ebf
testb %al, %al
je 0x17ca4
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x17ed7
movq %r12, %rdi
callq 0x1809e
leaq 0x80... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::get_default_flag_values(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline std::vector<std::pair<std::string, std::string>> get_default_flag_values(const std::string &str) {
std::vector<std::string> flags = split_names(str);
flags.erase(std::remove_if(flags.begin(),
flags.end(),
[](const std::string &name) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r13
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x96e0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x18554
leaq 0x48(%rsp), %rdi
callq 0x9b38
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18c13
movq %rsp, %rdi
movq 0x8(%rdi), %rdx... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::remove_default_flag_values(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline void remove_default_flag_values(std::string &flags) {
auto loc = flags.find_first_of('{');
while(loc != std::string::npos) {
auto finish = flags.find_first_of("},", loc + 1);
if((finish != std::string::npos) && (flags[finish] == '}')) {
flags.erase(flags.begin() + static_cast<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x7b
popq %rbp
leaq 0x2086d(%rip), %r14 # 0x38927
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x9a90
cmpq $-0x1, %rax
je 0x1810a
movq %rax, %r12
leaq 0x1(%rax), %r15
movq %rbx, %rdi
movq %r14, ... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::add_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)>, s... | Option *add_option(std::string option_name,
callback_t option_callback,
std::string option_description = "",
bool defaulted = false,
std::function<std::string()> func = {}) {
Option myopt{option_name, option_description,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp # imm = 0x348
movq %r9, %r15
movl %r8d, 0xc(%rsp)
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb8(%rsp), %rdi
callq 0x96e0
leaq 0x98(%rsp), %rdi
movq %rbp, %rsi
callq 0x96e0
leaq 0x78(%rsp), %rdi
mov... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::split_names(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline std::vector<std::string> split_names(std::string current) {
std::vector<std::string> output;
std::size_t val;
while((val = current.find(",")) != std::string::npos) {
output.push_back(trim_copy(current.substr(0, val)));
current = current.substr(val + 1);
}
output.push_back(trim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
pushq $-0x1
popq %rbp
movq %r14, %rdi
leaq 0x2071f(%rip), %rsi # 0x38ca9
xorl %edx, %edx
callq 0... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::rtrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline std::string &rtrim(std::string &str) {
auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
str.erase(it.base(), str.end());
return str;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq %rax, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x18976
movq (%r14), %rsi
movq (%rbx), %rdx
addq 0x8(%rbx), %rdx
movq %rbx, %rdi
callq 0x9900... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
bool CLI::detail::valid_later_char<char>(char) | inline bool valid_name_string(const std::string &str) {
if(str.empty() || !valid_first_char(str[0]))
return false;
for(auto c : str.substr(1))
if(!valid_later_char(c))
return false;
return true;
} | pushq %rbx
movl %edi, %ebx
callq 0x19ab0
leal -0x2d(%rbx), %ecx
cmpb $0x2, %cl
setb %cl
orb %cl, %al
popq %rbx
retq
| /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::clear() | void clear() {
parsed_ = 0;
pre_parse_called_ = false;
missing_.clear();
parsed_subcommands_.clear();
for(const Option_p &opt : options_) {
opt->clear();
}
for(const App_p &subc : subcommands_) {
subc->clear();
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x2a0(%rdi)
movb $0x0, 0x4e(%rdi)
addq $0x170, %rdi # imm = 0x170
callq 0x1b2d0
movq 0x1a0(%rbx), %rax
cmpq %rax, 0x1a8(%rbx)
je 0x1aec9
movq %rax, 0x1a8(%rbx)
movq 0xd8(%rbx), %r14
movq 0xe0(%rbx), %r15
cmpq %r15, %r14
je 0x1aeea
movq (%r14), %rdi
... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::_configure() | void _configure() {
if(default_startup == startup_mode::enabled) {
disabled_ = false;
} else if(default_startup == startup_mode::disabled) {
disabled_ = true;
}
for(const App_p &app : subcommands_) {
if(app->has_automatic_name_) {
app->... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x295(%rdi), %eax
cmpl $0x1, %eax
je 0x1b117
cmpl $0x2, %eax
jne 0x1b11c
movb $0x1, %al
jmp 0x1b119
xorl %eax, %eax
movb %al, 0x4d(%rbx)
movq 0x278(%rbx), %r14
movq 0x280(%rbx), %r15
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x1b16d
movq (%r14), %rd... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::run_callback(bool) | void run_callback(bool final_mode = false) {
pre_callback();
// in the main app if immediate_callback_ is set it runs the main callback before the used subcommands
if(!final_mode && parse_complete_callback_) {
parse_complete_callback_();
}
// run the callbacks for the... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testl %ebp, %ebp
jne 0x1b208
cmpq $0x0, 0x80(%rbx)
je 0x1b208
leaq 0x70(%rbx), %rdi
callq 0x2208c
leaq 0x1a0(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x201d6
movq (%r14), %r15
movq 0... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::_trigger_pre_parse(unsigned long) | void _trigger_pre_parse(std::size_t remaining_args) {
if(!pre_parse_called_) {
pre_parse_called_ = true;
if(pre_parse_callback_) {
pre_parse_callback_(remaining_args);
}
} else if(immediate_callback_) {
if(!name_.empty()) {
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4e(%rdi)
je 0x1b5d0
cmpb $0x1, 0x4f(%rbx)
jne 0x1b5ee
cmpq $0x0, 0x10(%rbx)
je 0x1b5ee
movq 0x2a0(%rbx), %r14
movups 0x170(%rbx), %xmm0
movaps %xmm0, (%rsp)
movq 0x180(%rbx), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x170(%rbx)
andq ... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::_process_extras() | void _process_extras() {
if(!(allow_extras_ || prefix_command_)) {
std::size_t num_left_over = remaining_size();
if(num_left_over > 0) {
throw ExtrasError(name_, remaining(false));
}
}
for(App_p &sub : subcommands_) {
if(sub->count... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
cmpb $0x0, 0x48(%rdi)
jne 0x1b7eb
cmpb $0x0, 0x4a(%r14)
jne 0x1b7eb
movq %r14, %rdi
xorl %esi, %esi
callq 0x1ea6e
testq %rax, %rax
jne 0x1b81f
movq 0x278(%r14), %rbx
movq 0x280(%r14), %r14
cmpq %r14, %rbx
je 0x1b816
movq (%rbx), %rdi
cmpq $0x0, 0x2a0(%rd... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::_move_to_missing(CLI::detail::Classifier, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void _move_to_missing(detail::Classifier val_type, const std::string &val) {
if(allow_extras_ || subcommands_.empty()) {
missing_.emplace_back(val_type, val);
return;
}
// allow extra arguments to be places in an option group if it is allowed there
for(auto &subc ... | pushq %rax
movl %esi, 0x4(%rsp)
cmpb $0x0, 0x48(%rdi)
jne 0x1bb09
movq 0x278(%rdi), %rcx
movq 0x280(%rdi), %rsi
cmpq %rsi, %rcx
je 0x1bb09
cmpq %rsi, %rcx
je 0x1bb09
movq (%rcx), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1bb03
cmpb $0x0, 0x48(%rax)
jne 0x1bb0c
addq $0x10, %rcx
jmp 0x1baee
movq %rdi, %rax
addq $0x170, %rax ... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::split_long(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline bool split_long(const std::string ¤t, std::string &name, std::string &value) {
if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
auto loc = current.find_first_of('=');
if(loc != std::string::npos) {
name = current.substr(2, loc - 2);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x3, 0x8(%rdi)
jb 0x1cd7a
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9510
leaq 0x1bae4(%rip), %rsi # 0x387b9
movq %r12, %rdi... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::split_windows_style(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline bool split_windows_style(const std::string ¤t, std::string &name, std::string &value) {
if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
auto loc = current.find_first_of(':');
if(loc != std::string::npos) {
name = current.substr(1, loc - 1);
... | cmpq $0x2, 0x8(%rdi)
jb 0x1cff0
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x1cff3
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0x19ab0
testb %al, %al
je 0x1cff3
pushq $0x3a
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
ca... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Option::check_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool check_name(std::string name) const {
if(name.length() > 2 && name[0] == '-' && name[1] == '-')
return check_lname(name.substr(2));
if(name.length() > 1 && name.front() == '-')
return check_sname(name.substr(1));
std::string local_pname = pname_;
if(ignore_u... | pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x3, %rax
jb 0x1d465
movq (%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x1d4a6
cmpb $0x2d, 0x1(%rax)
jne 0x1d473
leaq 0xe0(%rsp), %r15
pushq $0x2
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rdi
... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::_process_help_flags(bool, bool) const | const Option *get_help_ptr() const { return help_ptr_; } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x130(%rdi), %rcx
movq 0x138(%rdi), %rax
testq %rcx, %rcx
je 0x1dfa6
movq 0x200(%rcx), %r8
cmpq 0x1f8(%rcx), %r8
setne %cl
orb %sil, %cl
movl %ecx, %esi
testq %rax, %rax
je 0x1dfc0
movq 0x200(%rax), %rcx
cmpq 0x1f8(%rax), %rcx
setne %al
orb %dl, %al
movl %eax,... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::remaining[abi:cxx11](bool) const | std::vector<std::string> remaining(bool recurse = false) const {
std::vector<std::string> miss_list;
for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
miss_list.push_back(std::get<1>(miss));
}
// Get from a subcommand that may allow extras
if(re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x170(%rsi), %r15
movq 0x178(%rsi), %r12
cmpq %r12, %r15
je 0x1eb15
addq $0x8, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq ... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::join<std::vector<CLI::App*, std::allocator<CLI::App*>>, CLI::App::_process_requirements()::'lambda'(CLI::App const*), void>(std::vector<CLI::App*, std::allocator<CLI::App*>> const&, CLI::App::_process_requirements()::'lambda'(CL... | std::string join(const T &v, Callable func, std::string delim = ",") {
std::ostringstream s;
auto beg = std::begin(v);
auto end = std::end(v);
if(beg != end)
s << func(*beg++);
while(beg != end) {
s << delim << func(*beg++);
}
return s.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x97e0
movq (%r15), %rbp
movq 0x8(%r15), %rbx
cmpq %rbx, %rbp
je 0x1faa3
movq (%rbp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1f5cc
lea... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::Validator::get_description[abi:cxx11]() const | std::string get_description() const {
if(active_) {
return desc_function_();
}
return std::string{};
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x64(%rsi)
jne 0x20d68
movq %rbx, %rdi
callq 0x1a46a
jmp 0x20d78
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
| /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::ConfigItem::fullname[abi:cxx11]() const | std::string fullname() const {
std::vector<std::string> tmp = parents;
tmp.emplace_back(name);
return detail::join(tmp, ".");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x131ae
addq $0x18, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x21f48
leaq 0x17771(%rip), %rsi # 0x39195
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd310
leaq 0x8(%rsp), %rsi
leaq 0x2... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::split_up(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char) | inline std::vector<std::string> split_up(std::string str, char delimiter = '\0') {
const std::string delims("\'\"`");
auto find_ws = [delimiter](char ch) {
return (delimiter == '\0') ? (std::isspace<char>(ch, std::locale()) != 0) : (ch == delimiter);
};
trim(str);
std::vector<std::string> ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1693d(%rip), %rsi # 0x39006
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xd310
movq %r14, %rdi
callq 0x1879e
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
m... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::detail::remove_quotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline std::string &remove_quotes(std::string &str) {
if(str.length() > 1 && (str.front() == '"' || str.front() == '\'')) {
if(str.front() == str.back()) {
str.pop_back();
str.erase(str.begin(), str.begin() + 1);
}
}
return str;
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x2, %rax
jb 0x22a47
movq (%rbx), %rcx
movzbl (%rcx), %edx
cmpl $0x27, %edx
je 0x22a2a
cmpl $0x22, %edx
jne 0x22a47
cmpb -0x1(%rcx,%rax), %dl
jne 0x22a47
movq %rbx, %rdi
callq 0x9940
movq (%rbx), %rsi
leaq 0x1(%rsi), %rdx
movq %rbx, %rdi
callq 0x9900
movq %rbx, %rax... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
CLI::App::get_footer[abi:cxx11]() const | std::string get_footer() const { return (footer_callback_) ? footer_callback_() + '\n' + footer_ : footer_; } | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x120(%rsi)
je 0x2408e
leaq 0x110(%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1a46a
movq %rsp, %rdi
pushq $0xa
popq %rdx
movq %r15, %rsi
callq 0x1252c
addq $0xf0, %r14
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %r... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp |
getopt | int getopt(int nargc, char * const nargv[], const char *ostr)
{
static char *place = EMSG; /* option letter processing */
const char *oli; /* option letter list index */
if (optreset || !*place) { /* update scanning pointer */
optreset = 0;
if (optind >= na... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, 0x2018c6(%rip) # 0x346ed0
jne 0x14561c
movq 0x15265d(%rip), %rax # 0x297c70
cmpb $0x0, (%rax)
jne 0x1456c2
movl $0x0, 0x2018aa(%rip) # 0x346ed0
movl 0x152640(%rip), %eax # 0x297c6c
cmpl... | /cs248-spring-2018[P]Cardinal3D/src/getopt.c |
tinfl_decompress_mem_to_mem | size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len,
const void *pSrc_buf, size_t src_buf_len,
int flags) {
tinfl_decompressor decomp;
tinfl_status status;
tinfl_init(&decomp);
status =
tinfl_decompress(&decomp, (const... | subq $0x2b38, %rsp # imm = 0x2B38
movq %rdi, 0x2b30(%rsp)
movq %rsi, 0x2b28(%rsp)
movq %rdx, 0x2b20(%rsp)
movq %rcx, 0x2b18(%rsp)
movl %r8d, 0x2b14(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x2b20(%rsp), %rsi
movq 0x2b30(%rsp), %rcx
movq 0x2b30(%rsp), %r8
movl 0x2b14(%rsp), %eax
andl $-0x3, %eax
orl $0x4, %eax
leaq 0x... | /cs248-spring-2018[P]Cardinal3D/CS248/include/CS248/tinyexr.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.