name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>>(char const*, char const*, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&&) | FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c == '}' || c == ':') {
handler();
return begin;
}
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index = parse_nonnegative_int(begin, end, handler);
else
++begin;
if (begin == end || (*begin != '}' && *begin != ':'))
handler.on_error("invalid format string");
else
handler(index);
return begin;
}
if (!is_name_start(c)) {
handler.on_error("invalid format string");
return begin;
}
auto it = begin;
do {
++it;
} while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
return it;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x15f05
movzbl (%rdi), %eax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x7d, %eax
je 0x15e1a
cmpl $0x3a, %eax
jne 0x15e2f
movq %rbx, %rdi
callq 0x15f1e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leal -0x30(%rax), %ecx
movq %rsi, %r15
cmpb $0x9, %cl
ja 0x15e4d
cmpb $0x30, %al
jne 0x15eb7
incq %r14
xorl %eax, %eax
movq %r14, 0x8(%rsp)
jmp 0x15ecd
cmpb $0x5f, %al
je 0x15e6a
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x15e6a
leaq 0x43f6fa(%rip), %rsi # 0x45555a
movq %rbx, %rdi
callq 0x15fa2
jmp 0x15e22
leaq 0x1(%r14), %rax
cmpq %r15, %rax
je 0x15e96
movb (%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x15e6e
cmpb $0x5f, %cl
je 0x15e6e
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x15e6e
decq %rax
movq %rax, %r15
movq %r15, %rdi
subq %r14, %rdi
callq 0x10002
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x15fb2
movq %r15, %r14
jmp 0x15e22
leaq 0x8(%rsp), %r14
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rdi
callq 0x15f26
movq (%r14), %r14
cmpq %r15, %r14
je 0x15eec
movzbl (%r14), %ecx
cmpl $0x3a, %ecx
je 0x15ee0
cmpl $0x7d, %ecx
jne 0x15eec
movq %rbx, %rdi
movl %eax, %esi
callq 0x15faa
jmp 0x15efb
leaq 0x43f667(%rip), %rsi # 0x45555a
movq %rbx, %rdi
callq 0x15fa2
movq 0x8(%rsp), %r14
jmp 0x15e22
leaq 0x43f26f(%rip), %rdi # 0x45517b
leaq 0x440a15(%rip), %rdx # 0x456928
movl $0xa8e, %esi # imm = 0xA8E
callq 0xf9cb
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&>(char const*&, char const*, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&) | FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
ErrorHandler&& eh) {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
constexpr unsigned max_int = max_value<int>();
unsigned big = max_int / 10;
do {
// Check for overflow.
if (value > big) {
value = max_int + 1;
break;
}
value = value * 10 + unsigned(*begin - '0');
++begin;
} while (begin != end && '0' <= *begin && *begin <= '9');
if (value > max_int) eh.on_error("number is too big");
return static_cast<int>(value);
} | pushq %rbx
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x15f89
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x15f89
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x15f71
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x15f6b
movb (%rax), %cl
incq %rax
leal -0x30(%rcx), %r8d
cmpb $0xa, %r8b
jb 0x15f40
testl %ebx, %ebx
jns 0x15f85
jmp 0x15f76
movl $0x80000000, %ebx # imm = 0x80000000
leaq 0x43f3f1(%rip), %rsi # 0x45536e
movq %rdx, %rdi
callq 0x15fa2
movl %ebx, %eax
popq %rbx
retq
leaq 0x43f1eb(%rip), %rdi # 0x45517b
leaq 0x440991(%rip), %rdx # 0x456928
movl $0x92f, %esi # imm = 0x92F
callq 0xf9cb
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::get_dynamic_spec<fmt::v7::detail::width_checker, fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::detail::error_handler>(fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::detail::error_handler) | FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
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);
} | subq $0x18, %rsp
movl 0x30(%rsp), %ecx
leaq 0xf(%rsp), %rax
movq %rax, 0x10(%rsp)
decl %ecx
cmpl $0xe, %ecx
ja 0x1605a
leaq 0x43e419(%rip), %rdx # 0x45442c
leaq 0x20(%rsp), %rax
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rax), %rax
jmp 0x16064
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0x160d0
jmp 0x16064
movl (%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0x160b8
jmp 0x16064
movl (%rax), %eax
jmp 0x16064
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x10(%rsp), %rdi
callq 0x160ea
jmp 0x16064
leaq 0x10(%rsp), %rdi
callq 0x16104
movq %rax, %rcx
shrq $0x1f, %rcx
jne 0x1607b
addq $0x18, %rsp
retq
leaq 0x43f62b(%rip), %rsi # 0x4556a4
jmp 0x16082
leaq 0x43f2ec(%rip), %rsi # 0x45536e
leaq 0xf(%rsp), %rdi
callq 0xf73a
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::precision_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>>(char const*, char const*, fmt::v7::detail::precision_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&&) | FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c == '}' || c == ':') {
handler();
return begin;
}
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index = parse_nonnegative_int(begin, end, handler);
else
++begin;
if (begin == end || (*begin != '}' && *begin != ':'))
handler.on_error("invalid format string");
else
handler(index);
return begin;
}
if (!is_name_start(c)) {
handler.on_error("invalid format string");
return begin;
}
auto it = begin;
do {
++it;
} while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
return it;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x16358
movzbl (%rdi), %eax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x7d, %eax
je 0x1626d
cmpl $0x3a, %eax
jne 0x16282
movq %rbx, %rdi
callq 0x16370
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leal -0x30(%rax), %ecx
movq %rsi, %r15
cmpb $0x9, %cl
ja 0x162a0
cmpb $0x30, %al
jne 0x1630a
incq %r14
xorl %eax, %eax
movq %r14, 0x8(%rsp)
jmp 0x16320
cmpb $0x5f, %al
je 0x162bd
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x162bd
leaq 0x43f2a7(%rip), %rsi # 0x45555a
movq %rbx, %rdi
callq 0x163f4
jmp 0x16275
leaq 0x1(%r14), %rax
cmpq %r15, %rax
je 0x162e9
movb (%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x162c1
cmpb $0x5f, %cl
je 0x162c1
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x162c1
decq %rax
movq %rax, %r15
movq %r15, %rdi
subq %r14, %rdi
callq 0x10002
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x16404
movq %r15, %r14
jmp 0x16275
leaq 0x8(%rsp), %r14
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rdi
callq 0x16378
movq (%r14), %r14
cmpq %r15, %r14
je 0x1633f
movzbl (%r14), %ecx
cmpl $0x3a, %ecx
je 0x16333
cmpl $0x7d, %ecx
jne 0x1633f
movq %rbx, %rdi
movl %eax, %esi
callq 0x163fc
jmp 0x1634e
leaq 0x43f214(%rip), %rsi # 0x45555a
movq %rbx, %rdi
callq 0x163f4
movq 0x8(%rsp), %r14
jmp 0x16275
leaq 0x43ee1c(%rip), %rdi # 0x45517b
leaq 0x4405c2(%rip), %rdx # 0x456928
movl $0xa8e, %esi # imm = 0xA8E
callq 0xf9cb
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::precision_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&>(char const*&, char const*, fmt::v7::detail::precision_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&) | FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
ErrorHandler&& eh) {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
constexpr unsigned max_int = max_value<int>();
unsigned big = max_int / 10;
do {
// Check for overflow.
if (value > big) {
value = max_int + 1;
break;
}
value = value * 10 + unsigned(*begin - '0');
++begin;
} while (begin != end && '0' <= *begin && *begin <= '9');
if (value > max_int) eh.on_error("number is too big");
return static_cast<int>(value);
} | pushq %rbx
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x163db
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x163db
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x163c3
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x163bd
movb (%rax), %cl
incq %rax
leal -0x30(%rcx), %r8d
cmpb $0xa, %r8b
jb 0x16392
testl %ebx, %ebx
jns 0x163d7
jmp 0x163c8
movl $0x80000000, %ebx # imm = 0x80000000
leaq 0x43ef9f(%rip), %rsi # 0x45536e
movq %rdx, %rdi
callq 0x163f4
movl %ebx, %eax
popq %rbx
retq
leaq 0x43ed99(%rip), %rdi # 0x45517b
leaq 0x44053f(%rip), %rdx # 0x456928
movl $0x92f, %esi # imm = 0x92F
callq 0xf9cb
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::get_dynamic_spec<fmt::v7::detail::precision_checker, fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::detail::error_handler>(fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::detail::error_handler) | FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
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);
} | subq $0x18, %rsp
movl 0x30(%rsp), %ecx
leaq 0xf(%rsp), %rax
movq %rax, 0x10(%rsp)
decl %ecx
cmpl $0xe, %ecx
ja 0x164ad
leaq 0x43e002(%rip), %rdx # 0x454468
leaq 0x20(%rsp), %rax
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rax), %rax
jmp 0x164b7
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0x164f8
jmp 0x164b7
movl (%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0x164e0
jmp 0x164b7
movl (%rax), %eax
jmp 0x164b7
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x10(%rsp), %rdi
callq 0x16512
jmp 0x164b7
leaq 0x10(%rsp), %rdi
callq 0x1652c
movq %rax, %rcx
shrq $0x1f, %rcx
jne 0x164ce
addq $0x18, %rsp
retq
leaq 0x43f21c(%rip), %rsi # 0x4556e8
jmp 0x164d5
leaq 0x43ee99(%rip), %rsi # 0x45536e
leaq 0xf(%rsp), %rdi
callq 0xf73a
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()<float, 0>(float) | iterator operator()(T value) {
auto specs = specs_ ? *specs_ : format_specs();
if (const_check(is_supported_floating_point(value)))
out_ = detail::write(out_, value, specs, locale_);
else
FMT_ASSERT(false, "unsupported float argument type");
return out_;
} | pushq %rbx
movq 0x10(%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x1664a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x1665e
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x194da
movq %rax, (%rbx)
popq %rbx
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()<double, 0>(double) | iterator operator()(T value) {
auto specs = specs_ ? *specs_ : format_specs();
if (const_check(is_supported_floating_point(value)))
out_ = detail::write(out_, value, specs, locale_);
else
FMT_ASSERT(false, "unsupported float argument type");
return out_;
} | pushq %rbx
movq 0x10(%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x16686
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x1669a
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x1a4cb
movq %rax, (%rbx)
popq %rbx
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()(fmt::v7::basic_string_view<char>) | iterator operator()(basic_string_view<Char> value) {
if (specs_) {
check_string_type_spec(specs_->type, error_handler());
write(value, *specs_);
} else {
write(value);
}
return out_;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rax, %rax
je 0x1676d
movsbl 0x8(%rax), %edi
leaq 0xf(%rsp), %rsi
callq 0x1a87f
movq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1921c
jmp 0x1677b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a820
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write_int<int>(int, fmt::v7::basic_format_specs<char> const&) | void write_int(T value, const format_specs& spec) {
using uint_type = uint32_or_64_or_128_t<T>;
int_writer<iterator, Char, uint_type> w(out_, locale_, value, spec);
handle_int_type_spec(spec.type, w);
out_ = w.out;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
vmovups (%rdi), %xmm0
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
testl %esi, %esi
js 0x1685e
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x16871
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel %eax, %ecx
movb %cl, 0x1c(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0x16871
negl %esi
movb $0x2d, 0x1c(%rsp)
movl $0x1, 0x20(%rsp)
movl %esi, 0x18(%rsp)
movsbl 0x8(%rdx), %edi
movq %rsp, %r14
movq %r14, %rsi
callq 0x1688e
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex() | void on_hex() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = specs.type;
}
int num_digits = count_digits<4>(abs_value);
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<4, Char>(it, abs_value, num_digits,
specs.type != 'x');
});
} | pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x16966
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movl 0x20(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb %al, 0x1c(%rbx,%rcx)
movl 0x18(%rbx), %edi
callq 0x16e8c
movl 0x20(%rbx), %ecx
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x1c(%rbx), %rdx
movl %eax, %esi
vmovups 0x10(%rsp), %xmm0
vmovups %xmm0, (%rsp)
callq 0x16e9d
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin() | void on_bin() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(specs.type);
}
int num_digits = count_digits<1>(abs_value);
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<1, Char>(it, abs_value, num_digits);
});
} | pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x169d0
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movl 0x20(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb %al, 0x1c(%rbx,%rcx)
movl 0x18(%rbx), %edi
callq 0x170c1
movl 0x20(%rbx), %ecx
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x1c(%rbx), %rdx
movl %eax, %esi
vmovups 0x10(%rsp), %xmm0
vmovups %xmm0, (%rsp)
callq 0x170d1
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct() | void on_oct() {
int num_digits = count_digits<3>(abs_value);
if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
// Octal prefix '0' is counted as a digit, so only add it if precision
// is not greater than the number of digits.
prefix[prefix_size++] = '0';
}
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<3, Char>(it, abs_value, num_digits);
});
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %edi
callq 0x172d1
movq 0x10(%rbx), %r8
cmpb $0x0, 0x9(%r8)
jns 0x16a3f
cmpl %eax, 0x4(%r8)
jg 0x16a3f
cmpl $0x0, 0x18(%rbx)
je 0x16a3f
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movq (%rbx), %rdi
movl 0x20(%rbx), %ecx
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x1c(%rbx), %rdx
movl %eax, %esi
vmovups 0x10(%rsp), %xmm0
vmovups %xmm0, (%rsp)
callq 0x172e2
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_num() | void on_num() {
std::string groups = grouping<Char>(locale);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<Char>(locale);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits, n = num_digits;
std::string::const_iterator group = groups.cbegin();
while (group != groups.cend() && n > *group && *group > 0 &&
*group != max_value<char>()) {
size += sep_size;
n -= *group;
++group;
}
if (group == groups.cend()) size += sep_size * ((n - 1) / groups.back());
char digits[40];
format_decimal(digits, abs_value, num_digits);
basic_memory_buffer<Char> buffer;
size += static_cast<int>(prefix_size);
const auto usize = to_unsigned(size);
buffer.resize(usize);
basic_string_view<Char> s(&sep, sep_size);
// Index of a decimal digit with the least significant digit having index 0.
int digit_index = 0;
group = groups.cbegin();
auto p = buffer.data() + size - 1;
for (int i = num_digits - 1; i > 0; --i) {
*p-- = static_cast<Char>(digits[i]);
if (*group <= 0 || ++digit_index % *group != 0 ||
*group == max_value<char>())
continue;
if (group + 1 != groups.cend()) {
digit_index = 0;
++group;
}
std::uninitialized_copy(s.data(), s.data() + s.size(),
make_checked(p, s.size()));
p -= s.size();
}
*p-- = static_cast<Char>(*digits);
if (prefix_size != 0) *p = static_cast<Char>('-');
auto data = buffer.data();
out = write_padded<align::right>(
out, specs, usize, usize,
[=](iterator it) { return copy_str<Char>(data, data + size, it); });
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17579
cmpq $0x0, 0x8(%r14)
je 0x16ae0
movq 0x8(%rbx), %rdi
callq 0x175d9
movl %eax, %ebp
testb %al, %al
je 0x16aed
movl 0x18(%rbx), %edi
callq 0xf872
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl %eax, %r15d
movl %eax, %r14d
xorl %edi, %edi
leal (%rsi,%r15), %ecx
cmpq %rdi, %rsi
je 0x16afa
movsbl (%rdx,%rdi), %r8d
subl %r8d, %eax
jle 0x16b0c
addb $-0x7f, %r8b
cmpb $-0x7e, %r8b
jb 0x16b0c
incq %rdi
jmp 0x16ac2
movq %rbx, %rdi
callq 0x168f4
jmp 0x16c03
movq %rbx, %rdi
callq 0x168f4
jmp 0x16c03
movsbl -0x1(%rdx,%rsi), %esi
decl %eax
cltd
idivl %esi
movl %eax, %r15d
addl %ecx, %r15d
jmp 0x16b0f
addl %edi, %r15d
movl 0x18(%rbx), %esi
leaq 0x20(%rsp), %rdi
movl %r14d, %edx
callq 0xf8de
leaq 0x78(%rsp), %rax
leaq 0x62398d(%rip), %rcx # 0x63a4b8
movslq %r15d, %r15
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
movslq 0x20(%rbx), %rax
addq %rax, %r15
movl %r15d, %edi
callq 0x1085f
movl %eax, %r12d
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0xf996
movq 0x60(%rsp), %rax
movq (%rsp), %rdi
xorl %r8d, %r8d
xorl %ecx, %ecx
leaq -0x1(%rax,%r15), %rsi
cmpl $0x1, %r14d
jle 0x16bc3
movb 0x1f(%rsp,%r14), %al
decq %r14
movb %al, (%rsi)
decq %rsi
movsbl (%rdi), %r9d
testl %r9d, %r9d
jle 0x16b75
incl %ecx
movl %ecx, %eax
cltd
idivl %r9d
cmpb $0x7f, %r9b
je 0x16b75
testl %edx, %edx
jne 0x16b75
movq (%rsp), %rdx
leaq 0x1(%rdi), %rax
addq 0x8(%rsp), %rdx
movb %bpl, (%rsi)
cmpq %rdx, %rax
cmovneq %rax, %rdi
cmovnel %r8d, %ecx
decq %rsi
jmp 0x16b75
movb 0x20(%rsp), %al
movb %al, (%rsi)
cmpl $0x0, 0x20(%rbx)
je 0x16bd3
movb $0x2d, -0x1(%rsi)
movq 0x60(%rsp), %rax
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x48(%rsp), %r8
movq %rax, (%r8)
movl %r15d, 0x8(%r8)
movq %r12, %rdx
movq %r12, %rcx
callq 0x174e7
leaq 0x58(%rsp), %rdi
movq %rax, (%rbx)
callq 0xf632
movq %rsp, %rdi
callq 0xe956
addq $0x270, %rsp # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16c32
jmp 0x16c1f
leaq 0x58(%rsp), %rdi
movq %rax, %rbx
callq 0xf632
jmp 0x16c35
jmp 0x16c32
jmp 0x16c32
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe956
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x16d88
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::write_int_data<char>::write_int_data(int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&) | write_int_data(int num_digits, string_view prefix,
const basic_format_specs<Char>& specs)
: size(prefix.size() + to_unsigned(num_digits)), padding(0) {
if (specs.align == align::numeric) {
auto width = to_unsigned(specs.width);
if (width > size) {
padding = width - size;
size = width;
}
} else if (specs.precision > num_digits) {
size = prefix.size() + to_unsigned(specs.precision);
padding = to_unsigned(specs.precision - num_digits);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
callq 0x1085f
movl %eax, %eax
addq %r15, %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb 0x9(%r14), %al
andb $0xf, %al
cmpb $0x4, %al
jne 0x16d57
movl (%r14), %edi
callq 0x1085f
movl %eax, %eax
movq %rax, %rcx
subq (%rbx), %rcx
jbe 0x16d7d
movq %rcx, 0x8(%rbx)
movq %rax, (%rbx)
jmp 0x16d7d
movl 0x4(%r14), %edi
cmpl %ebp, %edi
jle 0x16d7d
callq 0x1085f
movl %eax, %eax
addq %r15, %rax
movq %rax, (%rbx)
movl 0x4(%r14), %edi
subl %ebp, %edi
callq 0x1085f
movl %eax, %eax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x440462(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x16e26
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x16f05
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x4402e5(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x16fa2
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<4u, char, fmt::v7::detail::buffer_appender<char>, unsigned int>(fmt::v7::detail::buffer_appender<char>, unsigned int, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x1704d
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x17083
jmp 0x17075
leaq 0xf(%rsp), %r15
movl %r14d, %esi
movl %ebp, %edx
movq %r15, %rdi
callq 0x17083
movslq %ebp, %rax
movq %r15, %rdi
movq %rbx, %rdx
leaq 0xf(%rsp,%rax), %rsi
callq 0xfa30
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<4u, char, unsigned int>(char*, unsigned int, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
} | movslq %edx, %r8
testl %ecx, %ecx
leaq 0x43e49b(%rip), %r9 # 0x45552a
leaq 0x44091a(%rip), %rdx # 0x4579b0
leaq -0x1(%rdi,%r8), %rcx
leaq (%rdi,%r8), %rax
cmovneq %r9, %rdx
movl %esi, %edi
movl %esi, %r8d
andl $0xf, %r8d
shrl $0x4, %edi
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx)
decq %rcx
cmpl $0xf, %esi
movl %edi, %esi
ja 0x170a5
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x17139
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x4400b1(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x171d6
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, char, fmt::v7::detail::buffer_appender<char>, unsigned int>(fmt::v7::detail::buffer_appender<char>, unsigned int, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x17276
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x172a9
jmp 0x1729b
movq %rsp, %r15
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x172a9
movslq %ebp, %rax
movq %r15, %rdi
movq %rbx, %rdx
leaq (%rsp,%rax), %rsi
callq 0xfa30
movq %rax, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<1u, char, unsigned int>(char*, unsigned int, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
} | movslq %edx, %rcx
movl %esi, %edx
leaq (%rdi,%rcx), %rax
leaq -0x1(%rdi,%rcx), %rcx
movl %esi, %edi
shrl %edx
andb $0x1, %dil
orb $0x30, %dil
movb %dil, (%rcx)
decq %rcx
cmpl $0x1, %esi
movl %edx, %esi
ja 0x172b7
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x1734a
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43fea0(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x173e8
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<3u, char, fmt::v7::detail::buffer_appender<char>, unsigned int>(fmt::v7::detail::buffer_appender<char>, unsigned int, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x17488
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x174be
jmp 0x174b0
leaq 0xd(%rsp), %r15
movl %r14d, %esi
movl %ebp, %edx
movq %r15, %rdi
callq 0x174be
movslq %ebp, %rax
movq %r15, %rdi
movq %rbx, %rdx
leaq 0xd(%rsp,%rax), %rsi
callq 0xfa30
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)&&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43fd0e(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x17628
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write_int<unsigned int>(unsigned int, fmt::v7::basic_format_specs<char> const&) | void write_int(T value, const format_specs& spec) {
using uint_type = uint32_or_64_or_128_t<T>;
int_writer<iterator, Char, uint_type> w(out_, locale_, value, spec);
handle_int_type_spec(spec.type, w);
out_ = w.out;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
vmovups (%rdi), %xmm0
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x17680
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel %eax, %ecx
movb %cl, 0x1c(%rsp)
movl $0x1, 0x20(%rsp)
movsbl 0x8(%rdx), %edi
movq %rsp, %r14
movq %r14, %rsi
callq 0x1688e
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write_int<long long>(long long, fmt::v7::basic_format_specs<char> const&) | void write_int(T value, const format_specs& spec) {
using uint_type = uint32_or_64_or_128_t<T>;
int_writer<iterator, Char, uint_type> w(out_, locale_, value, spec);
handle_int_type_spec(spec.type, w);
out_ = w.out;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
vmovups (%rdi), %xmm0
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
andl $0x0, 0x24(%rsp)
testq %rsi, %rsi
js 0x176e8
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x176fd
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel %eax, %ecx
movb %cl, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x176fd
negq %rsi
movb $0x2d, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movsbl 0x8(%rdx), %edi
movq %rsp, %r14
movq %r14, %rsi
callq 0x1771a
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::handle_int_type_spec<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>&>(char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>&) | FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
switch (spec) {
case 0:
case 'd':
handler.on_dec();
break;
case 'x':
case 'X':
handler.on_hex();
break;
case 'b':
case 'B':
handler.on_bin();
break;
case 'o':
handler.on_oct();
break;
#ifdef FMT_DEPRECATED_N_SPECIFIER
case 'n':
#endif
case 'L':
handler.on_num();
break;
case 'c':
handler.on_chr();
break;
default:
handler.on_error();
}
} | testl %edi, %edi
je 0x17746
cmpl $0x42, %edi
je 0x17756
cmpl $0x4c, %edi
je 0x1775e
cmpl $0x58, %edi
je 0x1774e
cmpl $0x62, %edi
je 0x17756
cmpl $0x63, %edi
je 0x1776e
cmpl $0x78, %edi
je 0x1774e
cmpl $0x6f, %edi
je 0x17766
cmpl $0x64, %edi
jne 0x17776
movq %rsi, %rdi
jmp 0x17780
movq %rsi, %rdi
jmp 0x177c4
movq %rsi, %rdi
jmp 0x17830
movq %rsi, %rdi
jmp 0x17902
movq %rsi, %rdi
jmp 0x1789c
movq %rsi, %rdi
jmp 0x17ad8
pushq %rax
movq %rsi, %rdi
callq 0x17aee
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex() | void on_hex() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = specs.type;
}
int num_digits = count_digits<4>(abs_value);
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<4, Char>(it, abs_value, num_digits,
specs.type != 'x');
});
} | pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x177f4
movl 0x24(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb $0x30, 0x20(%rbx,%rcx)
movl 0x24(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb %al, 0x20(%rbx,%rcx)
movq 0x18(%rbx), %rdi
callq 0x14d0a
movl 0x24(%rbx), %ecx
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x20(%rbx), %rdx
movl %eax, %esi
vmovups 0x10(%rsp), %xmm0
vmovups %xmm0, (%rsp)
callq 0x17ca1
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin() | void on_bin() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(specs.type);
}
int num_digits = count_digits<1>(abs_value);
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<1, Char>(it, abs_value, num_digits);
});
} | pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x17860
movl 0x24(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb $0x30, 0x20(%rbx,%rcx)
movl 0x24(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb %al, 0x20(%rbx,%rcx)
movq 0x18(%rbx), %rdi
callq 0x17e15
movl 0x24(%rbx), %ecx
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x20(%rbx), %rdx
movl %eax, %esi
vmovups 0x10(%rsp), %xmm0
vmovups %xmm0, (%rsp)
callq 0x17e29
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct() | void on_oct() {
int num_digits = count_digits<3>(abs_value);
if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
// Octal prefix '0' is counted as a digit, so only add it if precision
// is not greater than the number of digits.
prefix[prefix_size++] = '0';
}
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<3, Char>(it, abs_value, num_digits);
});
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1802e
movq 0x10(%rbx), %r8
cmpb $0x0, 0x9(%r8)
jns 0x178d3
cmpl %eax, 0x4(%r8)
jg 0x178d3
cmpq $0x0, 0x18(%rbx)
je 0x178d3
movl 0x24(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb $0x30, 0x20(%rbx,%rcx)
movq (%rbx), %rdi
movl 0x24(%rbx), %ecx
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x20(%rbx), %rdx
movl %eax, %esi
vmovups 0x10(%rsp), %xmm0
vmovups %xmm0, (%rsp)
callq 0x18043
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_num() | void on_num() {
std::string groups = grouping<Char>(locale);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<Char>(locale);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits, n = num_digits;
std::string::const_iterator group = groups.cbegin();
while (group != groups.cend() && n > *group && *group > 0 &&
*group != max_value<char>()) {
size += sep_size;
n -= *group;
++group;
}
if (group == groups.cend()) size += sep_size * ((n - 1) / groups.back());
char digits[40];
format_decimal(digits, abs_value, num_digits);
basic_memory_buffer<Char> buffer;
size += static_cast<int>(prefix_size);
const auto usize = to_unsigned(size);
buffer.resize(usize);
basic_string_view<Char> s(&sep, sep_size);
// Index of a decimal digit with the least significant digit having index 0.
int digit_index = 0;
group = groups.cbegin();
auto p = buffer.data() + size - 1;
for (int i = num_digits - 1; i > 0; --i) {
*p-- = static_cast<Char>(digits[i]);
if (*group <= 0 || ++digit_index % *group != 0 ||
*group == max_value<char>())
continue;
if (group + 1 != groups.cend()) {
digit_index = 0;
++group;
}
std::uninitialized_copy(s.data(), s.data() + s.size(),
make_checked(p, s.size()));
p -= s.size();
}
*p-- = static_cast<Char>(*digits);
if (prefix_size != 0) *p = static_cast<Char>('-');
auto data = buffer.data();
out = write_padded<align::right>(
out, specs, usize, usize,
[=](iterator it) { return copy_str<Char>(data, data + size, it); });
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17579
cmpq $0x0, 0x8(%r14)
je 0x17975
movq 0x8(%rbx), %rdi
callq 0x175d9
movl %eax, %ebp
testb %al, %al
je 0x17982
movq 0x18(%rbx), %rdi
callq 0xfb66
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl %eax, %r15d
movl %eax, %r14d
xorl %edi, %edi
leal (%rsi,%r15), %ecx
cmpq %rdi, %rsi
je 0x1798f
movsbl (%rdx,%rdi), %r8d
subl %r8d, %eax
jle 0x179a1
addb $-0x7f, %r8b
cmpb $-0x7e, %r8b
jb 0x179a1
incq %rdi
jmp 0x17957
movq %rbx, %rdi
callq 0x17780
jmp 0x17a99
movq %rbx, %rdi
callq 0x17780
jmp 0x17a99
movsbl -0x1(%rdx,%rsi), %esi
decl %eax
cltd
idivl %esi
movl %eax, %r15d
addl %ecx, %r15d
jmp 0x179a4
addl %edi, %r15d
movq 0x18(%rbx), %rsi
leaq 0x20(%rsp), %rdi
movl %r14d, %edx
callq 0xfb8f
leaq 0x78(%rsp), %rax
leaq 0x622af7(%rip), %rcx # 0x63a4b8
movslq %r15d, %r15
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
movslq 0x24(%rbx), %rax
addq %rax, %r15
movl %r15d, %edi
callq 0x1085f
movl %eax, %r12d
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0xf996
movq 0x60(%rsp), %rax
movq (%rsp), %rdi
xorl %r8d, %r8d
xorl %ecx, %ecx
leaq -0x1(%rax,%r15), %rsi
cmpl $0x1, %r14d
jle 0x17a59
movb 0x1f(%rsp,%r14), %al
decq %r14
movb %al, (%rsi)
decq %rsi
movsbl (%rdi), %r9d
testl %r9d, %r9d
jle 0x17a0b
incl %ecx
movl %ecx, %eax
cltd
idivl %r9d
cmpb $0x7f, %r9b
je 0x17a0b
testl %edx, %edx
jne 0x17a0b
movq (%rsp), %rdx
leaq 0x1(%rdi), %rax
addq 0x8(%rsp), %rdx
movb %bpl, (%rsi)
cmpq %rdx, %rax
cmovneq %rax, %rdi
cmovnel %r8d, %ecx
decq %rsi
jmp 0x17a0b
movb 0x20(%rsp), %al
movb %al, (%rsi)
cmpl $0x0, 0x24(%rbx)
je 0x17a69
movb $0x2d, -0x1(%rsi)
movq 0x60(%rsp), %rax
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x48(%rsp), %r8
movq %rax, (%r8)
movl %r15d, 0x8(%r8)
movq %r12, %rdx
movq %r12, %rcx
callq 0x18249
leaq 0x58(%rsp), %rdi
movq %rax, (%rbx)
callq 0xf632
movq %rsp, %rdi
callq 0xe956
addq $0x270, %rsp # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17ac4
jmp 0x17ab5
leaq 0x58(%rsp), %rdi
movq %rax, %rbx
callq 0xf632
jmp 0x17ac7
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe956
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x17b9d
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x17d09
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43f4e1(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x17da6
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x17e91
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43f359(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x17f2e
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x17fcf
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x18002
jmp 0x17ff4
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x18002
movslq %ebp, %rax
movq %r15, %rdi
movq %rbx, %rdx
leaq (%rsp,%rax), %rsi
callq 0xfa30
movq %rax, %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x180ab
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<3u, char, unsigned long>(char*, unsigned long, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
} | movslq %edx, %rcx
movq %rsi, %rdx
leaq (%rdi,%rcx), %rax
leaq -0x1(%rdi,%rcx), %rcx
movl %esi, %edi
shrq $0x3, %rdx
andb $0x7, %dil
orb $0x30, %dil
movb %dil, (%rcx)
decq %rcx
cmpq $0x7, %rsi
movq %rdx, %rsi
ja 0x1822b
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::handle_int_type_spec<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>&>(char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>&) | FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
switch (spec) {
case 0:
case 'd':
handler.on_dec();
break;
case 'x':
case 'X':
handler.on_hex();
break;
case 'b':
case 'B':
handler.on_bin();
break;
case 'o':
handler.on_oct();
break;
#ifdef FMT_DEPRECATED_N_SPECIFIER
case 'n':
#endif
case 'L':
handler.on_num();
break;
case 'c':
handler.on_chr();
break;
default:
handler.on_error();
}
} | testl %edi, %edi
je 0x1841d
cmpl $0x42, %edi
je 0x1842d
cmpl $0x4c, %edi
je 0x18435
cmpl $0x58, %edi
je 0x18425
cmpl $0x62, %edi
je 0x1842d
cmpl $0x63, %edi
je 0x18445
cmpl $0x78, %edi
je 0x18425
cmpl $0x6f, %edi
je 0x1843d
cmpl $0x64, %edi
jne 0x1844d
movq %rsi, %rdi
jmp 0x18456
movq %rsi, %rdi
jmp 0x1849e
movq %rsi, %rdi
jmp 0x1850e
movq %rsi, %rdi
jmp 0x185ea
movq %rsi, %rdi
jmp 0x1857e
movq %rsi, %rdi
jmp 0x187c8
pushq %rax
movq %rsi, %rdi
callq 0x187de
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_num() | void on_num() {
std::string groups = grouping<Char>(locale);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<Char>(locale);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits, n = num_digits;
std::string::const_iterator group = groups.cbegin();
while (group != groups.cend() && n > *group && *group > 0 &&
*group != max_value<char>()) {
size += sep_size;
n -= *group;
++group;
}
if (group == groups.cend()) size += sep_size * ((n - 1) / groups.back());
char digits[40];
format_decimal(digits, abs_value, num_digits);
basic_memory_buffer<Char> buffer;
size += static_cast<int>(prefix_size);
const auto usize = to_unsigned(size);
buffer.resize(usize);
basic_string_view<Char> s(&sep, sep_size);
// Index of a decimal digit with the least significant digit having index 0.
int digit_index = 0;
group = groups.cbegin();
auto p = buffer.data() + size - 1;
for (int i = num_digits - 1; i > 0; --i) {
*p-- = static_cast<Char>(digits[i]);
if (*group <= 0 || ++digit_index % *group != 0 ||
*group == max_value<char>())
continue;
if (group + 1 != groups.cend()) {
digit_index = 0;
++group;
}
std::uninitialized_copy(s.data(), s.data() + s.size(),
make_checked(p, s.size()));
p -= s.size();
}
*p-- = static_cast<Char>(*digits);
if (prefix_size != 0) *p = static_cast<Char>('-');
auto data = buffer.data();
out = write_padded<align::right>(
out, specs, usize, usize,
[=](iterator it) { return copy_str<Char>(data, data + size, it); });
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17579
cmpq $0x0, 0x8(%r14)
je 0x18661
movq 0x8(%rbx), %rdi
callq 0x175d9
movl %eax, %ebp
testb %al, %al
je 0x1866e
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0xfd6f
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl %eax, %r15d
movl %eax, %r14d
xorl %edi, %edi
leal (%rsi,%r15), %ecx
cmpq %rdi, %rsi
je 0x1867b
movsbl (%rdx,%rdi), %r8d
subl %r8d, %eax
jle 0x1868d
addb $-0x7f, %r8b
cmpb $-0x7e, %r8b
jb 0x1868d
incq %rdi
jmp 0x18643
movq %rbx, %rdi
callq 0x18456
jmp 0x18789
movq %rbx, %rdi
callq 0x18456
jmp 0x18789
movsbl -0x1(%rdx,%rsi), %esi
decl %eax
cltd
idivl %esi
movl %eax, %r15d
addl %ecx, %r15d
jmp 0x18690
addl %edi, %r15d
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
leaq 0x20(%rsp), %rdi
movl %r14d, %ecx
callq 0xfde3
leaq 0x78(%rsp), %rax
leaq 0x621e07(%rip), %rcx # 0x63a4b8
movslq %r15d, %r15
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
movslq 0x34(%rbx), %rax
addq %rax, %r15
movl %r15d, %edi
callq 0x1085f
movl %eax, %r12d
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0xf996
movq 0x60(%rsp), %rax
movq (%rsp), %rdi
xorl %r8d, %r8d
xorl %ecx, %ecx
leaq -0x1(%rax,%r15), %rsi
cmpl $0x1, %r14d
jle 0x18749
movb 0x1f(%rsp,%r14), %al
decq %r14
movb %al, (%rsi)
decq %rsi
movsbl (%rdi), %r9d
testl %r9d, %r9d
jle 0x186fb
incl %ecx
movl %ecx, %eax
cltd
idivl %r9d
cmpb $0x7f, %r9b
je 0x186fb
testl %edx, %edx
jne 0x186fb
movq (%rsp), %rdx
leaq 0x1(%rdi), %rax
addq 0x8(%rsp), %rdx
movb %bpl, (%rsi)
cmpq %rdx, %rax
cmovneq %rax, %rdi
cmovnel %r8d, %ecx
decq %rsi
jmp 0x186fb
movb 0x20(%rsp), %al
movb %al, (%rsi)
cmpl $0x0, 0x34(%rbx)
je 0x18759
movb $0x2d, -0x1(%rsi)
movq 0x60(%rsp), %rax
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x48(%rsp), %r8
movq %rax, (%r8)
movl %r15d, 0x8(%r8)
movq %r12, %rdx
movq %r12, %rcx
callq 0x190c5
leaq 0x58(%rsp), %rdi
movq %rax, (%rbx)
callq 0xf632
movq %rsp, %rdi
callq 0xe956
addq $0x270, %rsp # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x187b4
jmp 0x187a5
leaq 0x58(%rsp), %rdi
movq %rax, %rbx
callq 0xf632
jmp 0x187b7
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe956
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x1888d
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e95d(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x1892a
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)) | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
vmovups %xmm0, 0x10(%rcx)
movl %esi, 0x28(%rcx)
movq %rbx, %rsi
movq %rax, 0x20(%rcx)
callq 0x18a27
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e7c3(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x18ac4
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<4u, char, fmt::v7::detail::buffer_appender<char>, unsigned __int128>(fmt::v7::detail::buffer_appender<char>, unsigned __int128, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl %ecx, %edi
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r12b, %r8d
testq %rax, %rax
je 0x18b7f
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x18bb7
jmp 0x18ba7
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x18bb7
movslq %ebp, %rax
movq %r12, %rdi
movq %rbx, %rdx
leaq (%rsp,%rax), %rsi
callq 0xfa30
movq %rax, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<4u, char, unsigned __int128>(char*, unsigned __int128, int, bool) | inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
} | movslq %ecx, %r9
leaq 0x43c969(%rip), %r10 # 0x45552a
leaq 0x43ede8(%rip), %rcx # 0x4579b0
testl %r8d, %r8d
leaq (%rdi,%r9), %rax
leaq -0x1(%rdi,%r9), %rdi
cmovneq %r10, %rcx
pushq $0xf
popq %r8
movq %rdx, %r9
movl %esi, %r10d
andl $0xf, %r10d
movq %rdx, %r11
shldq $0x3c, %rsi, %r11
shrq $0x4, %r9
movb (%rcx,%r10), %r10b
movb %r10b, (%rdi)
decq %rdi
cmpq %rsi, %r8
movl $0x0, %esi
sbbq %rdx, %rsi
movq %r11, %rsi
movq %r9, %rdx
jb 0x18bdf
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e549(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x18d3e
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, char, fmt::v7::detail::buffer_appender<char>, unsigned __int128>(fmt::v7::detail::buffer_appender<char>, unsigned __int128, int, bool) | inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl %ecx, %edi
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r12b, %r8d
testq %rax, %rax
je 0x18def
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x18e2a
jmp 0x18e17
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x18e2a
movslq %ebp, %rax
movq %r12, %rdi
movq %rbx, %rdx
leaq (%rsp,%rax), %rsi
callq 0xfa30
movq %rax, %rbx
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)&&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e130(%rip), %rcx # 0x457229
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %r14, %rdi
movq %rax, %rsi
callq 0x19158
subq %rbp, %r15
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&) | OutputIt write(OutputIt out, basic_string_view<StrChar> s,
const basic_format_specs<Char>& specs) {
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));
auto width = specs.width != 0
? count_code_points(basic_string_view<StrChar>(data, size))
: 0;
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded(out, specs, size, width, [=](iterator it) {
return copy_str<Char>(data, data + size, it);
});
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl 0x4(%rcx), %edi
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
testl %edi, %edi
js 0x19268
callq 0x1085f
movl %eax, %eax
cmpq %r14, %rax
jae 0x19268
movl 0x4(%rbx), %edi
callq 0x1085f
movl %eax, %eax
cmpq %rax, %r14
cmovaeq %rax, %r14
cmpl $0x0, (%rbx)
je 0x1927d
movq %r12, %rdi
movq %r14, %rsi
callq 0x192a5
movq %rax, %rcx
jmp 0x1927f
xorl %ecx, %ecx
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, (%r8)
movq %r14, 0x8(%r8)
callq 0x192c6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_char<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_specs<char> const&)::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_char<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_specs<char> const&)::'lambda'(fmt::v7::detail::buffer_appender<char>)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43dad7(%rip), %rcx # 0x456f48
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%rbx), %eax
addq $0xa, %rbx
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r15, %rbp
callq 0xf897
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1087f
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xf9f2
subq %rbp, %r15
movq %r12, %rdi
movq %rbx, %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1087f
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, float, 0>(fmt::v7::detail::buffer_appender<char>, float, fmt::v7::basic_format_specs<char>, fmt::v7::detail::locale_ref) | OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
locale_ref loc = {}) {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (std::signbit(value)) { // value < 0 is false for NaN so use signbit.
fspecs.sign = sign::minus;
value = -value;
} else if (fspecs.sign == sign::minus) {
fspecs.sign = sign::none;
}
if (!std::isfinite(value))
return write_nonfinite(out, std::isinf(value), specs, fspecs);
if (specs.align == align::numeric && fspecs.sign) {
auto it = reserve(out, 1);
*it++ = static_cast<Char>(data::signs[fspecs.sign]);
out = base_iterator(out, it);
fspecs.sign = sign::none;
if (specs.width != 0) --specs.width;
}
memory_buffer buffer;
if (fspecs.format == float_format::hex) {
if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
return write_bytes(out, {buffer.data(), buffer.size()}, specs);
}
int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
if (fspecs.format == float_format::exp) {
if (precision == max_value<int>())
FMT_THROW(format_error("number is too big"));
else
++precision;
}
if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
fspecs.use_grisu = is_fast_float<T>();
int exp = format_float(promote_float(value), precision, fspecs, buffer);
fspecs.precision = precision;
Char point =
fspecs.locale ? decimal_point<Char>(loc) : static_cast<Char>('.');
auto fp = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
return write_float(out, fp, specs, fspecs, point);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
leaq 0x10(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
vmovaps %xmm0, 0x20(%rsp)
movq %rsi, (%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(%r12)
callq 0x12720
vmovdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax, 0x8(%rsp)
movzbl 0x9(%r12), %eax
movl $0x304, %ecx # imm = 0x304
shrq $0x20, %rbx
andl $0xffff00ff, %ebx # imm = 0xFFFF00FF
bextrl %ecx, %eax, %edx
movl %edx, %ecx
shll $0x8, %ecx
orl %ebx, %ecx
vmovd %xmm0, %esi
movl %ecx, 0xc(%rsp)
testl %esi, %esi
js 0x19554
cmpb $0x1, %dl
je 0x19564
movl %ecx, %ebx
jmp 0x19568
vpxord 0x43ad9e(%rip){1to4}, %xmm0, %xmm0 # 0x4542fc
orl $0x100, %ebx # imm = 0x100
movl %ebx, 0xc(%rsp)
vucomiss 0x43ad90(%rip), %xmm0 # 0x454300
je 0x1965d
andb $0xf, %al
cmpb $0x4, %al
jne 0x195d3
movl %ebx, %eax
andl $0xff00, %eax # imm = 0xFF00
je 0x195d3
vmovaps %xmm0, 0x20(%rsp)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xf897
movq %rax, %r15
movzbl %bh, %eax
leaq 0x43d9aa(%rip), %rcx # 0x456f4d
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
movb (%rax,%rcx), %al
movb %al, (%rsi)
callq 0xf9f2
movl 0x10(%rsp), %eax
andl $0xffff00ff, %ebx # imm = 0xFFFF00FF
movl %ebx, 0xc(%rsp)
testl %eax, %eax
je 0x195cd
decl %eax
movl %eax, 0x10(%rsp)
vmovaps 0x20(%rsp), %xmm0
leaq 0x68(%rsp), %rax
leaq 0x620ed9(%rip), %rcx # 0x63a4b8
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
cmpb $0x3, %bl
jne 0x1967d
shrl $0x8, %ebx
andl $0xff, %ebx
je 0x1962a
leaq 0x43d93e(%rip), %rsi # 0x456f4d
movl %ebx, %eax
addq %rax, %rsi
leaq 0x48(%rsp), %rdi
vmovaps %xmm0, 0x20(%rsp)
callq 0xf9f2
vmovaps 0x20(%rsp), %xmm0
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
vcvtss2sd %xmm0, %xmm0, %xmm0
leaq 0x48(%rsp), %rdx
callq 0x19786
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
callq 0x12abe
jmp 0x1970c
setae %al
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movzbl %al, %esi
callq 0x100d3
movq %rax, %rbx
jmp 0x19719
movl 0x14(%rsp), %eax
cmpb $0x0, 0x18(%rsp)
pushq $0x6
popq %rbp
cmovel %eax, %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
cmpb $0x1, %bl
jne 0x196a4
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
je 0x1972c
incl %ebp
orl $0xc0000, %ebx # imm = 0xC0000
vcvtss2sd %xmm0, %xmm0, %xmm0
movl %ebx, 0xc(%rsp)
movq 0x8(%rsp), %r12
leaq 0x48(%rsp), %rdx
movl %ebp, %edi
movq %r12, %rsi
callq 0x19a44
movl %eax, %ebx
movb $0x2e, %al
btq $0x31, %r12
movl %ebp, 0x8(%rsp)
jae 0x196dd
movq %r14, %rdi
callq 0x14670
movq 0x50(%rsp), %rcx
leaq 0x38(%rsp), %rsi
movl 0x58(%rsp), %r9d
movq %rcx, (%rsi)
movq 0x8(%rsp), %rcx
movl %r9d, 0x8(%rsi)
movl %ebx, 0xc(%rsi)
movsbl %al, %r8d
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x12f4d
leaq 0x48(%rsp), %rdi
movq %rax, %rbx
callq 0xf632
movq %rbx, %rax
addq $0x260, %rsp # imm = 0x260
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb210
movq %rax, %r14
leaq 0x43bc30(%rip), %rsi # 0x45536e
movq %rax, %rdi
callq 0xf780
movq 0x623873(%rip), %rdx # 0x63cfc0
leaq 0x620cfc(%rip), %rsi # 0x63a450
movq %r14, %rdi
callq 0xb3c0
jmp 0x19771
movq %r14, %rdi
movq %rax, %rbx
callq 0xb570
jmp 0x19774
jmp 0x19771
jmp 0x19771
jmp 0x19771
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf632
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::snprintf_float<double>(double, int, fmt::v7::detail::float_specs, fmt::v7::detail::buffer<char>&) | int snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
static_assert(!std::is_same<T, float>::value, "");
// Subtract 1 to account for the difference in precision since we use %e for
// both general and exponent format.
if (specs.format == float_format::general ||
specs.format == float_format::exp)
precision = (precision >= 0 ? precision : 6) - 1;
// Build the format string.
enum { max_format_size = 7 }; // The longest format is "%#.*Le".
char format[max_format_size];
char* format_ptr = format;
*format_ptr++ = '%';
if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
if (precision >= 0) {
*format_ptr++ = '.';
*format_ptr++ = '*';
}
if (std::is_same<T, long double>()) *format_ptr++ = 'L';
*format_ptr++ = specs.format != float_format::hex
? (specs.format == float_format::fixed ? 'f' : 'e')
: (specs.upper ? 'A' : 'a');
*format_ptr = '\0';
// Format using snprintf.
auto offset = buf.size();
for (;;) {
auto begin = buf.data() + offset;
auto capacity = buf.capacity() - offset;
#ifdef FMT_FUZZ
if (precision > 100000)
throw std::runtime_error(
"fuzz mode - avoid large allocation inside snprintf");
#endif
// Suppress the warning about a nonliteral format string.
// Cannot use auto because of a bug in MinGW (#1532).
int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
int result = precision >= 0
? snprintf_ptr(begin, capacity, format, precision, value)
: snprintf_ptr(begin, capacity, format, value);
if (result < 0) {
// The buffer will grow exponentially.
buf.try_reserve(buf.capacity() + 1);
continue;
}
auto size = to_unsigned(result);
// Size equal to capacity means that the last character was truncated.
if (size >= capacity) {
buf.try_reserve(size + offset + 1); // Add 1 for the terminating '\0'.
continue;
}
auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
if (specs.format == float_format::fixed) {
if (precision == 0) {
buf.try_resize(size);
return 0;
}
// Find and remove the decimal point.
auto end = begin + size, p = end;
do {
--p;
} while (is_digit(*p));
int fraction_size = static_cast<int>(end - p - 1);
std::memmove(p, p + 1, to_unsigned(fraction_size));
buf.try_resize(size - 1);
return -fraction_size;
}
if (specs.format == float_format::hex) {
buf.try_resize(size + offset);
return 0;
}
// Find and parse the exponent.
auto end = begin + size, exp_pos = end;
do {
--exp_pos;
} while (*exp_pos != 'e');
char sign = exp_pos[1];
assert(sign == '+' || sign == '-');
int exp = 0;
auto p = exp_pos + 2; // Skip 'e' and sign.
do {
assert(is_digit(*p));
exp = exp * 10 + (*p++ - '0');
} while (p != end);
if (sign == '-') exp = -exp;
int fraction_size = 0;
if (exp_pos != begin + 1) {
// Remove trailing zeros.
auto fraction_end = exp_pos - 1;
while (*fraction_end == '0') --fraction_end;
// Move the fractional part left to get rid of the decimal point.
fraction_size = static_cast<int>(fraction_end - begin - 1);
std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
}
buf.try_resize(to_unsigned(fraction_size) + offset + 1);
return exp - fraction_size;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdx), %rax
vmovsd %xmm0, 0x10(%rsp)
cmpq 0x10(%rdx), %rax
jbe 0x19a0d
shrq $0x20, %rsi
movq %rdx, %rbx
leal -0x1(%rdi), %eax
testl %edi, %edi
pushq $0x5
popq %rbp
cmovnsl %eax, %ebp
cmpb $0x2, %sil
movb $0x25, 0x1(%rsp)
cmovael %edi, %ebp
btl $0x14, %esi
setae %al
cmpb $0x3, %sil
setne %cl
orb %al, %cl
jne 0x197e3
leaq 0x3(%rsp), %rax
movb $0x23, -0x1(%rax)
jmp 0x197e8
leaq 0x2(%rsp), %rax
testl %ebp, %ebp
js 0x197f5
movw $0x2a2e, (%rax) # imm = 0x2A2E
addq $0x2, %rax
movq %rsi, 0x20(%rsp)
cmpb $0x3, %sil
jne 0x1980f
btl $0x10, %esi
setae %cl
shlb $0x5, %cl
orb $0x41, %cl
jmp 0x19819
cmpb $0x2, %sil
sete %cl
addb $0x65, %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
movq %rdi, 0x18(%rsp)
movq 0x10(%rbx), %r12
leaq 0x1(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rbx), %r14
movq 0x8(%rbx), %r15
leaq 0x1(%rsp), %rdx
addq %r12, %r15
subq %r12, %r14
movq %r15, %rdi
movq %r14, %rsi
testl %ebp, %ebp
js 0x19860
vmovsd 0x10(%rsp), %xmm0
movb $0x1, %al
movl %ebp, %ecx
callq 0xb310
jmp 0x1986d
vmovsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0xb310
testl %eax, %eax
js 0x1988d
movl %eax, %edi
callq 0x1085f
movl %eax, %r13d
cmpq %r13, %r14
ja 0x198a7
addq 0x8(%rsp), %r13
cmpq %r13, 0x18(%rbx)
jae 0x19832
jmp 0x1989a
movq 0x18(%rbx), %r13
cmpq $-0x1, %r13
je 0x19832
incq %r13
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *(%rax)
jmp 0x19832
movq 0x20(%rsp), %rax
cmpb $0x2, %al
je 0x198c6
movzbl %al, %eax
cmpl $0x3, %eax
jne 0x19913
addq %r13, %r12
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x199d4
cmpl $0x0, 0x18(%rsp)
je 0x199ce
addq %r13, %r15
pushq $0x1
popq %r12
movb -0x2(%r15,%r12), %al
decq %r12
addb $-0x30, %al
cmpb $0xa, %al
jb 0x198d8
movl %r12d, %edi
negl %edi
callq 0x1085f
leaq -0x1(%r15,%r12), %rdi
leaq (%r15,%r12), %rsi
movl %eax, %edx
callq 0xb140
decl %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf996
jmp 0x199dc
leaq -0x1(%r13,%r15), %rax
pushq $0x2
popq %rcx
cmpb $0x65, -0x2(%rax,%rcx)
leaq -0x1(%rcx), %rcx
jne 0x1991b
leaq (%r13,%rcx), %rdx
movzbl -0x1(%r15,%rdx), %edi
cmpl $0x2b, %edi
je 0x1993f
cmpl $0x2d, %edi
jne 0x19a25
leaq (%r15,%r13), %r8
leaq -0x3(%r13,%rcx), %rsi
xorl %r9d, %r9d
leaq -0x3(%rcx,%r8), %rax
movzbl (%r8,%rcx), %r10d
leal -0x30(%r10), %r11d
cmpb $0xa, %r11b
jae 0x199ee
imull $0xa, %r9d, %r9d
incq %rcx
leal -0x30(%r9,%r10), %r9d
jne 0x19950
movl %r9d, %r12d
negl %r12d
cmpb $0x2d, %dil
cmovnel %r9d, %r12d
xorl %ebp, %ebp
cmpq $0x3, %rdx
je 0x199b0
leaq 0x1(%r15), %r14
movl %esi, %ebp
decl %ebp
cmpb $0x30, (%rax)
leaq -0x1(%rax), %rax
je 0x1998d
movl %ebp, %edi
addq $0x2, %r15
callq 0x1085f
movl %eax, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb140
movl %ebp, %edi
callq 0x1085f
movq 0x8(%rsp), %rsi
movl %eax, %eax
movq %rbx, %rdi
addq %rax, %rsi
callq 0xf996
subl %ebp, %r12d
jmp 0x199dc
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf996
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43ba21(%rip), %rdi # 0x455416
leaq 0x43b8a5(%rip), %rsi # 0x4552a1
leaq 0x43bd4d(%rip), %rcx # 0x455750
movl $0xa12, %edx # imm = 0xA12
callq 0xb150
leaq 0x43b88d(%rip), %rdi # 0x4552a1
leaq 0x43b97c(%rip), %rdx # 0x455397
movl $0x9c0, %esi # imm = 0x9C0
callq 0xf9cb
leaq 0x43b978(%rip), %rdi # 0x4553a4
leaq 0x43b86e(%rip), %rsi # 0x4552a1
leaq 0x43bd16(%rip), %rcx # 0x455750
movl $0xa0e, %edx # imm = 0xA0E
callq 0xb150
| /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, long double, 0>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, long double, fmt::v7::basic_format_specs<char>, fmt::v7::detail::locale_ref) | OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
locale_ref loc = {}) {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (std::signbit(value)) { // value < 0 is false for NaN so use signbit.
fspecs.sign = sign::minus;
value = -value;
} else if (fspecs.sign == sign::minus) {
fspecs.sign = sign::none;
}
if (!std::isfinite(value))
return write_nonfinite(out, std::isinf(value), specs, fspecs);
if (specs.align == align::numeric && fspecs.sign) {
auto it = reserve(out, 1);
*it++ = static_cast<Char>(data::signs[fspecs.sign]);
out = base_iterator(out, it);
fspecs.sign = sign::none;
if (specs.width != 0) --specs.width;
}
memory_buffer buffer;
if (fspecs.format == float_format::hex) {
if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
return write_bytes(out, {buffer.data(), buffer.size()}, specs);
}
int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
if (fspecs.format == float_format::exp) {
if (precision == max_value<int>())
FMT_THROW(format_error("number is too big"));
else
++precision;
}
if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
fspecs.use_grisu = is_fast_float<T>();
int exp = format_float(promote_float(value), precision, fspecs, buffer);
fspecs.precision = precision;
Char point =
fspecs.locale ? decimal_point<Char>(loc) : static_cast<Char>('.');
auto fp = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
return write_float(out, fp, specs, fspecs, point);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
fldt 0x2b0(%rsp)
fld %st(0)
fstpt 0x24(%rsp)
fstpt 0x40(%rsp)
leaq 0x30(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
movswq 0x48(%rsp), %r13
movq %rsi, (%r12)
leaq 0x60(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(%r12)
callq 0x12720
movq %rax, %rbx
movq %rax, 0x18(%rsp)
movzbl 0x9(%r12), %eax
movl $0x304, %ecx # imm = 0x304
shrq $0x20, %rbx
andl $0xffff00ff, %ebx # imm = 0xFFFF00FF
bextrl %ecx, %eax, %edx
movl %edx, %ecx
shll $0x8, %ecx
orl %ebx, %ecx
movl %ecx, 0x1c(%rsp)
testq %r13, %r13
js 0x1cb91
fldt 0x24(%rsp)
cmpb $0x1, %dl
jne 0x1cba3
movl %ebx, 0x1c(%rsp)
jmp 0x1cba5
orl $0x100, %ebx # imm = 0x100
movl %ebx, 0x1c(%rsp)
fldt 0x24(%rsp)
fchs
jmp 0x1cba5
movl %ecx, %ebx
flds 0x437755(%rip) # 0x454300
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
je 0x1cc93
andb $0xf, %al
cmpb $0x4, %al
jne 0x1cc00
movl %ebx, %eax
andl $0xff00, %eax # imm = 0xFF00
je 0x1cc00
fstpt 0x24(%rsp)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x1b99b
movzbl %bh, %ecx
leaq 0x43a36e(%rip), %rdx # 0x456f4d
andl $0xffff00ff, %ebx # imm = 0xFFFF00FF
movb (%rcx,%rdx), %cl
movb %cl, (%rax)
movl %ebx, 0x1c(%rsp)
movl 0x30(%rsp), %eax
testl %eax, %eax
je 0x1cbfc
decl %eax
movl %eax, 0x30(%rsp)
fldt 0x24(%rsp)
leaq 0x80(%rsp), %rax
leaq 0x61d8a9(%rip), %rcx # 0x63a4b8
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
cmpb $0x3, %bl
jne 0x1ccb5
shrl $0x8, %ebx
andl $0xff, %ebx
je 0x1cc56
leaq 0x43a30e(%rip), %rsi # 0x456f4d
movl %ebx, %eax
addq %rax, %rsi
leaq 0x60(%rsp), %rdi
fstpt 0x24(%rsp)
callq 0xf9f2
fldt 0x24(%rsp)
movl 0x34(%rsp), %edi
movq 0x18(%rsp), %rsi
leaq 0x60(%rsp), %rdx
fstpt (%rsp)
callq 0x127e7
fldz
fstp %st(0)
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq %r15, %rdi
callq 0x1cdc3
fldz
movq %rax, %rbx
fstp %st(0)
jmp 0x1cd46
setae %al
leaq 0x30(%rsp), %rdx
leaq 0x18(%rsp), %rcx
fstp %st(0)
movq %r15, %rdi
movzbl %al, %esi
callq 0x1b51a
movq %rax, %rbx
jmp 0x1cd50
movl 0x34(%rsp), %eax
cmpb $0x0, 0x38(%rsp)
pushq $0x6
popq %rbp
cmovel %eax, %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
cmpb $0x1, %bl
jne 0x1ccdc
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
je 0x1cd65
incl %ebp
andl $0xfff7ffff, %ebx # imm = 0xFFF7FFFF
movl %ebx, 0x1c(%rsp)
movq 0x18(%rsp), %r12
leaq 0x60(%rsp), %rdx
fstpt (%rsp)
movl %ebp, %edi
movq %r12, %rsi
callq 0x12ade
movl %eax, %ebx
movb $0x2e, %al
btq $0x31, %r12
movl %ebp, 0x18(%rsp)
jae 0x1cd14
movq %r14, %rdi
callq 0x14670
movq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %rsi
movl 0x70(%rsp), %r9d
movq %rcx, (%rsi)
movq 0x18(%rsp), %rcx
movl %r9d, 0x8(%rsi)
movl %ebx, 0xc(%rsi)
movsbl %al, %r8d
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x1cde3
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf632
movq %rbx, %rax
addq $0x278, %rsp # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
pushq $0x10
popq %rdi
callq 0xb210
movq %rax, %r14
leaq 0x4385f5(%rip), %rsi # 0x45536e
movq %rax, %rdi
callq 0xf780
movq 0x620238(%rip), %rdx # 0x63cfc0
leaq 0x61d6c1(%rip), %rsi # 0x63a450
movq %r14, %rdi
callq 0xb3c0
jmp 0x1cdae
movq %r14, %rdi
movq %rax, %rbx
callq 0xb570
jmp 0x1cdb1
jmp 0x1cdae
jmp 0x1cdae
jmp 0x1cdae
fstp %st(0)
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf632
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char) | OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
auto sign = fspecs.sign;
size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
int output_exp = fp.exponent + significand_size - 1;
auto use_exp_format = [=]() {
if (fspecs.format == float_format::exp) return true;
if (fspecs.format != float_format::general) return false;
// Use the fixed notation if the exponent is in [exp_lower, exp_upper),
// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
const int exp_lower = -4, exp_upper = 16;
return output_exp < exp_lower ||
output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
};
if (use_exp_format()) {
int num_zeros = 0;
if (fspecs.showpoint) {
num_zeros = (std::max)(fspecs.precision - significand_size, 0);
size += to_unsigned(num_zeros);
} else if (significand_size == 1) {
decimal_point = Char();
}
auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
int exp_digits = 2;
if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
char exp_char = fspecs.upper ? 'E' : 'e';
auto write = [=](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
// Insert a decimal point after the first digit and add an exponent.
it = write_significand(it, significand, significand_size, 1,
decimal_point);
if (num_zeros > 0) it = std::fill_n(it, num_zeros, zero);
*it++ = static_cast<Char>(exp_char);
return write_exponent<Char>(output_exp, it);
};
return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
: base_iterator(out, write(reserve(out, size)));
}
int exp = fp.exponent + significand_size;
if (fp.exponent >= 0) {
// 1234e5 -> 123400000[.0+]
size += to_unsigned(fp.exponent);
int num_zeros = fspecs.precision - exp;
#ifdef FMT_FUZZ
if (num_zeros > 5000)
throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
#endif
if (fspecs.showpoint) {
if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
if (num_zeros > 0) size += to_unsigned(num_zeros);
}
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand<Char>(it, significand, significand_size);
it = std::fill_n(it, fp.exponent, zero);
if (!fspecs.showpoint) return it;
*it++ = decimal_point;
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
} else if (exp > 0) {
// 1234e-2 -> 12.34[0+]
int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand(it, significand, significand_size, exp,
decimal_point);
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
}
// 1234e-6 -> 0.001234
int num_zeros = -exp;
if (significand_size == 0 && fspecs.precision >= 0 &&
fspecs.precision < num_zeros) {
num_zeros = fspecs.precision;
}
size += 2 + to_unsigned(num_zeros);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
*it++ = zero;
if (num_zeros == 0 && significand_size == 0 && !fspecs.showpoint) return it;
*it++ = decimal_point;
it = std::fill_n(it, num_zeros, zero);
return write_significand<Char>(it, significand, significand_size);
});
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x38(%rsp)
movb %r8b, 0xb(%rsp)
movq %rcx, %r14
shrq $0x28, %r14
movq %rcx, %r13
shrq $0x20, %r13
xorl %ebx, %ebx
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
movl %r8d, 0x34(%rsp)
movq (%rsi), %rax
andl $0xff, %r14d
setne %bl
movq %rax, 0x40(%rsp)
movq %rax, 0x58(%rsp)
movl 0x8(%rsi), %r15d
movl %r14d, 0x10(%rsp)
movl %r15d, %edi
movl %r15d, 0x14(%rsp)
callq 0x1085f
addl %eax, %ebx
leaq 0x98(%rsp), %rdi
movq %rbx, 0x28(%rsp)
movl 0xc(%r12), %ebx
movq %rbp, (%rdi)
leal -0x1(%r15,%rbx), %eax
movl %eax, 0x48(%rsp)
movl %eax, 0x8(%rdi)
callq 0x1d206
testb %al, %al
je 0x1cea5
addl %r15d, %ebx
btl $0x14, %r13d
movq %r13, 0x50(%rsp)
jb 0x1cee9
movl 0x34(%rsp), %ebp
movq 0x28(%rsp), %r13
xorl %r12d, %r12d
cmpl $0x1, %r15d
movzbl %bpl, %ebp
cmovel %r12d, %ebp
jmp 0x1cf0c
movl 0xc(%r12), %edi
leal (%r15,%rdi), %ebx
movl %ebx, 0x4c(%rsp)
testl %edi, %edi
js 0x1cf9f
callq 0x1085f
movl %eax, %r15d
movl 0x38(%rsp), %edi
movl 0x3c(%rsp), %eax
addq 0x28(%rsp), %r15
subl %ebx, %edi
btl $0x14, %eax
movl %edi, 0xc(%rsp)
jb 0x1d03b
movq 0x20(%rsp), %rbx
jmp 0x1d069
subl %r15d, %ebp
movl %ebp, %eax
sarl $0x1f, %eax
andnl %ebp, %eax, %r12d
movl %r12d, %edi
callq 0x1085f
movq 0x28(%rsp), %r13
movl 0x34(%rsp), %ebp
movl %eax, %eax
addq %rax, %r13
pushq $0x1
popq %rax
subl %ebx, %eax
testl %ebx, %ebx
movl 0x48(%rsp), %ebx
cmovgl %ebx, %eax
xorl %ecx, %ecx
cmpl $0x3e8, %eax # imm = 0x3E8
setge %cl
addl $0x3, %ecx
cmpl $0x64, %eax
pushq $0x2
popq %rax
cmovgel %ecx, %eax
cmpb $0x1, %bpl
pushq $0x3
popq %rdi
sbbl $0x0, %edi
addl %eax, %edi
callq 0x1085f
movl %eax, %edx
addq %r13, %rdx
btl $0x10, 0x50(%rsp)
movq 0x58(%rsp), %rcx
movq 0x18(%rsp), %rsi
movl %r14d, 0x60(%rsp)
setae %al
movq %rcx, 0x68(%rsp)
movl %r15d, 0x70(%rsp)
movb %bpl, 0x74(%rsp)
movl %r12d, 0x78(%rsp)
shlb $0x5, %al
orb $0x45, %al
movb %al, 0x7c(%rsp)
movl %ebx, 0x80(%rsp)
cmpl $0x0, (%rsi)
jle 0x1d01c
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rcx
callq 0x1d233
jmp 0x1d0b7
testl %ebx, %ebx
jle 0x1d0cf
shll $0xb, %r13d
subl %r15d, %ebp
leaq 0xc(%rsp), %rbx
sarl $0x1f, %r13d
andl %r13d, %ebp
movl %ebp, %eax
sarl $0x1f, %eax
movl %ebp, (%rbx)
andnl %ebp, %eax, %edi
callq 0x1085f
leal 0x1(%rax), %edx
leaq 0x10(%rsp), %rax
leaq 0x60(%rsp), %rcx
leaq 0x40(%rsp), %rdi
leaq 0x14(%rsp), %rsi
addq 0x28(%rsp), %rdx
movq %rax, (%rcx)
movq %rdi, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
leaq 0x4c(%rsp), %rdi
leaq 0xb(%rsp), %rsi
movq %rdi, 0x18(%rcx)
movq %rsi, 0x20(%rcx)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rbx, 0x28(%rcx)
callq 0x1d2dc
jmp 0x1d0b7
movq 0x20(%rsp), %rbx
movq %rdx, %rsi
movq %rbx, %rdi
callq 0x1b99b
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x1d23e
jmp 0x1d0ba
movq 0x20(%rsp), %rbx
testl %edi, %edi
setg %cl
cmpb $0x2, %al
sete %al
orb %cl, %al
je 0x1d054
testl %edi, %edi
jg 0x1d05f
jmp 0x1d069
movl $0x1, 0xc(%rsp)
pushq $0x1
popq %rdi
callq 0x1085f
movl %eax, %eax
addq %rax, %r15
movq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rax
leaq 0x60(%rsp), %rcx
leaq 0x40(%rsp), %rdx
leaq 0x14(%rsp), %rdi
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x38(%rsp), %rdx
movq %rdi, 0x10(%rcx)
movq %r12, 0x18(%rcx)
leaq 0xb(%rsp), %rdi
movq %rdx, 0x20(%rcx)
leaq 0xc(%rsp), %rdx
movq %rdi, 0x28(%rcx)
movq %rbx, %rdi
movq %rdx, 0x30(%rcx)
movq %r15, %rdx
callq 0x1d2d1
movq %rax, %rbx
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negl %ebx
cmpl %ebx, %ebp
movl %ebx, %edi
cmovll %ebp, %edi
testl %ebp, %ebp
cmovsl %ebx, %edi
testl %r15d, %r15d
cmovnel %ebx, %edi
leaq 0xc(%rsp), %rbx
movl %edi, (%rbx)
callq 0x1085f
leal 0x2(%rax), %edx
leaq 0x10(%rsp), %rax
leaq 0x60(%rsp), %rcx
leaq 0x14(%rsp), %rdi
leaq 0x38(%rsp), %rsi
addq 0x28(%rsp), %rdx
movq %rax, (%rcx)
movq %rbx, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
leaq 0xb(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rdi, 0x20(%rcx)
movq %rsi, 0x28(%rcx)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1d2e7
jmp 0x1d0b7
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_bytes<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&)::'lambda'(char*)&>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_bytes<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&)::'lambda'(char*)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r14
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbx, %rax
movzbl 0xe(%r14), %esi
leaq 0x439dc3(%rip), %rcx # 0x456f48
movq %r12, 0x10(%rsp)
movq %r12, %rdi
cmovaeq %rax, %r15
movzbl 0x9(%r14), %eax
addq $0xa, %r14
imulq %r15, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %rbp, %rsi
shrxq %rax, %r15, %r13
callq 0x1b99b
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1b9bc
movq 0x8(%rsp), %rcx
movq %rax, %rbp
movq 0x8(%rcx), %rbx
testq %rbx, %rbx
je 0x1d1de
movq (%rcx), %rsi
movq %rbp, %rdi
movq %rbx, %rdx
callq 0xb140
addq %rbx, %rbp
subq %r13, %r15
movq %r14, %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1b9bc
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&>(fmt::v7::detail::big_decimal_fp, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&) | inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %edi
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
callq 0x1085f
movl %eax, %eax
xorl %r12d, %r12d
subq %rbp, %rax
movzbl 0xe(%r14), %esi
leaq 0x439bcf(%rip), %rcx # 0x457229
movq %rbx, %rdi
cmovaeq %rax, %r12
movzbl 0x9(%r14), %eax
addq $0xa, %r14
imulq %r12, %rsi
andl $0xf, %eax
movb (%rax,%rcx), %al
addq %r13, %rsi
shrxq %rax, %r12, %rbp
callq 0x1b99b
movq %rax, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1b9bc
movq %r15, %rdi
movq %rax, %rsi
callq 0x1d6be
subq %rbp, %r12
movq %rax, %rdi
movq %r14, %rdx
movq %r12, %rsi
callq 0x1b9bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char const*) | OutputIt write(OutputIt out, const Char* value) {
if (!value) {
FMT_THROW(format_error("string pointer is null"));
} else {
auto length = std::char_traits<Char>::length(value);
out = write(out, basic_string_view<Char>(value, length));
}
return out;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1d7c4
movq %rdi, %r14
movq %rsi, %rdi
movq %rsi, %rbx
callq 0xb220
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d807
pushq $0x10
popq %rdi
callq 0xb210
movq %rax, %rbx
leaq 0x437d3d(%rip), %rsi # 0x455513
movq %rax, %rdi
callq 0xf780
movq 0x61f7db(%rip), %rdx # 0x63cfc0
leaq 0x61cc64(%rip), %rsi # 0x63a450
movq %rbx, %rdi
callq 0xb3c0
movq %rbx, %rdi
movq %rax, %r14
callq 0xb570
movq %r14, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
decltype(fp.begin()) fmt::v7::formatter<fmt::v7::basic_string_view<char>, char, void>::parse<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>(fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>&) | FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
using handler_type = detail::dynamic_specs_handler<ParseContext>;
auto type = detail::type_constant<T, Char>::value;
detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
type);
auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
auto eh = ctx.error_handler();
switch (type) {
case detail::type::none_type:
FMT_ASSERT(false, "invalid argument type");
break;
case detail::type::int_type:
case detail::type::uint_type:
case detail::type::long_long_type:
case detail::type::ulong_long_type:
case detail::type::int128_type:
case detail::type::uint128_type:
case detail::type::bool_type:
handle_int_type_spec(specs_.type,
detail::int_type_checker<decltype(eh)>(eh));
break;
case detail::type::char_type:
handle_char_specs(
&specs_, detail::char_specs_checker<decltype(eh)>(specs_.type, eh));
break;
case detail::type::float_type:
if (detail::const_check(FMT_USE_FLOAT))
detail::parse_float_type_spec(specs_, eh);
else
FMT_ASSERT(false, "float support disabled");
break;
case detail::type::double_type:
if (detail::const_check(FMT_USE_DOUBLE))
detail::parse_float_type_spec(specs_, eh);
else
FMT_ASSERT(false, "double support disabled");
break;
case detail::type::long_double_type:
if (detail::const_check(FMT_USE_LONG_DOUBLE))
detail::parse_float_type_spec(specs_, eh);
else
FMT_ASSERT(false, "long double support disabled");
break;
case detail::type::cstring_type:
detail::handle_cstring_type_spec(
specs_.type, detail::cstring_type_checker<decltype(eh)>(eh));
break;
case detail::type::string_type:
detail::check_string_type_spec(specs_.type, eh);
break;
case detail::type::pointer_type:
detail::check_pointer_type_spec(specs_.type, eh);
break;
case detail::type::custom_type:
// Custom format specifiers should be checked in parse functions of
// formatter specializations.
break;
}
return it;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %rdx
movq %rdi, %rbx
movq %rdi, (%rdx)
movq %rdi, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movl $0xd, 0x20(%rdx)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
addq %rdi, %rsi
callq 0x1e85b
movsbl 0x8(%rbx), %edi
leaq 0xf(%rsp), %rsi
movq %rax, %r14
callq 0x1e931
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_format_specs<char, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>>&) | FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
SpecHandler&& handler) {
if (begin == end) return begin;
begin = parse_align(begin, end, handler);
if (begin == end) return begin;
// Parse sign.
switch (to_ascii(*begin)) {
case '+':
handler.on_plus();
++begin;
break;
case '-':
handler.on_minus();
++begin;
break;
case ' ':
handler.on_space();
++begin;
break;
}
if (begin == end) return begin;
if (*begin == '#') {
handler.on_hash();
if (++begin == end) return begin;
}
// Parse zero flag.
if (*begin == '0') {
handler.on_zero();
if (++begin == end) return begin;
}
begin = parse_width(begin, end, handler);
if (begin == end) return begin;
// Parse precision.
if (*begin == '.') {
begin = parse_precision(begin, end, handler);
}
// Parse type.
if (begin != end && *begin != '}') handler.on_type(*begin++);
return begin;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1e928
movq %rbx, %rdi
movq %rdx, %r14
movq %rsi, %r15
callq 0x1e94e
movq %rax, %rbx
cmpq %r15, %rax
je 0x1e928
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x1e8ac
cmpl $0x2d, %eax
je 0x1e8a2
cmpl $0x2b, %eax
jne 0x1e8b7
movq %r14, %rdi
callq 0x1ea1e
jmp 0x1e8b4
movq %r14, %rdi
callq 0x1ea3c
jmp 0x1e8b4
movq %r14, %rdi
callq 0x1ea5a
incq %rbx
cmpq %r15, %rbx
je 0x1e928
movb (%rbx), %al
cmpb $0x23, %al
jne 0x1e8d4
movq %r14, %rdi
callq 0x1ea78
incq %rbx
cmpq %r15, %rbx
je 0x1e928
movb (%rbx), %al
cmpb $0x30, %al
jne 0x1e8e8
movq %r14, %rdi
callq 0x1ea8e
incq %rbx
cmpq %r15, %rbx
je 0x1e928
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1eab3
movq %rax, %rbx
cmpq %r15, %rax
je 0x1e928
cmpb $0x2e, (%rbx)
jne 0x1e914
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1eb58
movq %rax, %rbx
cmpq %r15, %rbx
je 0x1e928
movb (%rbx), %al
cmpb $0x7d, %al
je 0x1e928
movq (%r14), %rcx
incq %rbx
movb %al, 0x8(%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_align<char, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>>&) | FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
Handler&& handler) {
FMT_ASSERT(begin != end, "");
auto align = align::none;
auto p = begin + code_point_length(begin);
if (p >= end) p = begin;
for (;;) {
switch (to_ascii(*p)) {
case '<':
align = align::left;
break;
case '>':
align = align::right;
break;
#if FMT_DEPRECATED_NUMERIC_ALIGN
case '=':
align = align::numeric;
break;
#endif
case '^':
align = align::center;
break;
}
if (align != align::none) {
if (p != begin) {
auto c = *begin;
if (c == '{')
return handler.on_error("invalid fill character '{'"), begin;
handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
begin = p + 1;
} else
++begin;
handler.on_align(align);
break;
} else if (p == begin) {
break;
}
p = begin;
}
return begin;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x1ea05
movzbl (%rdi), %eax
movq %rdx, %rbx
leaq 0x435935(%rip), %rdx # 0x4542a0
movq %rdi, %r14
movl %eax, %ecx
shrl $0x3, %ecx
movsbq (%rcx,%rdx), %r15
movl $0x80ff0000, %edx # imm = 0x80FF0000
btl %ecx, %edx
adcq %rdi, %r15
cmpq %rsi, %r15
cmovaeq %rdi, %r15
movzbl (%r15), %ecx
cmpl $0x5e, %ecx
je 0x1e9a7
cmpl $0x3e, %ecx
je 0x1e9ab
cmpl $0x3c, %ecx
je 0x1e9af
cmpq %r14, %r15
movq %r14, %r15
jne 0x1e98a
jmp 0x1e9f7
pushq $0x3
jmp 0x1e9b1
pushq $0x2
jmp 0x1e9b1
pushq $0x1
popq %rbp
movq %r15, %rdi
subq %r14, %rdi
je 0x1e9cf
cmpb $0x7b, %al
jne 0x1e9d4
leaq 0x436c53(%rip), %rsi # 0x455618
movq %rbx, %rdi
callq 0x1ec20
jmp 0x1e9f7
movq %r14, %r15
jmp 0x1e9e7
callq 0x10002
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x15c80
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1ec2a
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43676f(%rip), %rdi # 0x45517b
leaq 0x437f15(%rip), %rdx # 0x456928
movl $0xaed, %esi # imm = 0xAED
callq 0xf9cb
nop
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
decltype(fp0.out()) fmt::v7::formatter<fmt::v7::basic_string_view<char>, char, void>::format<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>(fmt::v7::basic_string_view<char> const&, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&) | auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
specs_.width_ref, ctx);
detail::handle_dynamic_spec<detail::precision_checker>(
specs_.precision, specs_.precision_ref, ctx);
using af = detail::arg_formatter<typename FormatContext::iterator,
typename FormatContext::char_type>;
return visit_format_arg(af(ctx, nullptr, &specs_),
detail::make_arg<FormatContext>(val));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x20(%rdi), %rax
movq %rsi, %rbx
movq %rdx, %rsi
movq %rdx, %r14
movq %rdi, %r15
movq %rax, 0x10(%rsp)
vmovups 0x10(%rdi), %xmm0
vmovups %xmm0, (%rsp)
callq 0x1f255
movq 0x38(%r15), %rax
leaq 0x4(%r15), %rdi
movq %r14, %rsi
movq %rax, 0x10(%rsp)
vmovups 0x28(%r15), %xmm0
vmovups %xmm0, (%rsp)
callq 0x1f2be
movq (%r14), %rax
movq 0x18(%r14), %rcx
leaq 0x20(%rsp), %rdi
vxorps %xmm0, %xmm0, %xmm0
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq %r15, 0x10(%rdi)
movq %r14, 0x18(%rdi)
vmovups %xmm0, 0x20(%rdi)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x16730
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::write_buffer<char>(std::basic_ostream<char, std::char_traits<char>>&, fmt::v7::detail::buffer<char>&) | void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
const Char* buf_data = buf.data();
using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
unsigned_streamsize size = buf.size();
unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
do {
unsigned_streamsize n = size <= max_size ? size : max_size;
os.write(buf_data, static_cast<std::streamsize>(n));
buf_data += n;
size -= n;
} while (size != 0);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r12
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
movq %rdi, %rbx
cmpq %r13, %r12
movq %r13, %r15
movq %rbx, %rdi
movq %r14, %rsi
cmovbq %r12, %r15
movq %r15, %rdx
callq 0xb2d0
addq %r15, %r14
subq %r15, %r12
jne 0x1fe23
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/ostream.h |
void fmt::v7::print<char [7], std::basic_string_view<char, std::char_traits<char>> const&, int, char>(std::basic_ostream<char, std::char_traits<char>>&, char const (&) [7], std::basic_string_view<char, std::char_traits<char>> const&, int&&) | void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
vprint(os, to_string_view(format_str),
fmt::make_args_checked<Args...>(format_str, args...));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rbx
movq %rdx, %r14
callq 0xf277
movq (%r14), %rcx
movq 0x8(%r14), %rsi
movl (%rbx), %edi
movq %rsp, %r8
movq %rsi, (%r8)
movq %rcx, 0x8(%r8)
movq %rdi, 0x10(%r8)
pushq $0x1d
popq %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1fd97
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/ostream.h |
bench::show_to_console(std::vector<bench::element, std::allocator<bench::element>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void show_to_console(const std::vector<element>& current, std::string name)
{
const auto model_size{ models.size() };
const auto solver_size{ solvers.size() };
std::vector<int> row_length(solvers.size(), 5);
int current_row_length = { 10 };
for (size_t i{ 0 }; i != model_size; ++i) {
for (size_t j{ 0 }; j != solver_size; ++j) {
if (is_valid(array(i, j))) {
auto digits = get_digits_number(array(i, j));
if (digits > row_length[j])
row_length[j] = digits;
}
}
}
for (size_t i{ 0 }; i != model_size; ++i) {
if (current[i].success && is_valid(current[i].solution)) {
auto digits = get_digits_number(current[i].solution);
if (digits > current_row_length)
current_row_length = digits;
}
}
auto modelname_lenght_max =
std::max(static_cast<std::string::size_type>(4),
std::max_element(models.cbegin(),
models.cend(),
[](const auto& lhs, const auto& rhs) {
return lhs.size() < rhs.size();
})
->size());
fmt::print("{:^{}} | ", "file", modelname_lenght_max);
for (std::size_t solver{ 0 }; solver != solver_size; ++solver)
fmt::print("{:>{}} ",
solvers[solver].name().substr(0, 10),
row_length[solver]);
fmt::print("{:>{}}\n", name, current_row_length);
for (size_t i{ 0 }; i != model_size; ++i) {
fmt::print("{:^{}} | ", models[i].name(), modelname_lenght_max);
auto lower = std::numeric_limits<double>::max();
auto upper = std::numeric_limits<double>::lowest();
for (std::size_t solver{ 0 }, end_solver(solvers.size());
solver != end_solver;
++solver) {
if (is_valid(array(i, solver)) && lower > array(i, solver))
lower = array(i, solver);
if (is_valid(array(i, solver)) && upper < array(i, solver))
upper = array(i, solver);
}
if (current[i].success) {
if (is_valid(current[i].solution) &&
lower > current[i].solution)
lower = current[i].solution;
if (is_valid(current[i].solution) &&
upper < current[i].solution)
upper = current[i].solution;
}
for (std::size_t solver{ 0 }, end_solver(solvers.size());
solver != end_solver;
++solver) {
if (array(i, solver) == lower)
fmt::print(fg(fmt::color::green),
"{:>{}.3f} ",
array(i, solver),
row_length[solver]);
else if (array(i, solver) == upper)
fmt::print(fg(fmt::color::blue),
"{:>{}.3f} ",
array(i, solver),
row_length[solver]);
else
fmt::print(
"{:>{}.3f} ", array(i, solver), row_length[solver]);
}
if (current[i].solution == lower)
fmt::print(fg(fmt::color::green),
"{:>{}.3f} ",
current[i].solution,
current_row_length);
else if (current[i].solution == upper)
fmt::print(fg(fmt::color::blue),
"{:>{}.3f} ",
current[i].solution,
current_row_length);
else
fmt::print(
"{:>{}.3f} ", current[i].solution, current_row_length);
fmt::print("\n");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %r13
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
subq (%rdi), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
subq 0x18(%rdi), %r13
leaq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rcx
movl $0x5, (%rdx)
sarq $0x5, %r13
movq %r13, %rsi
movq %rax, 0x40(%rsp)
movq %rax, %rbx
callq 0x2682a
movl $0xa, 0xc(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq 0x40(%rsp), %r12
je 0x22c3a
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x22c31
movq 0x48(%r14), %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
imulq %r15, %rax
addq 0x30(%r14), %rax
vmovq (%rax,%rbp,8), %xmm0
vmovq %xmm0, %rax
btrq $0x3f, %rax
cmpq %rcx, %rax
je 0x22c2c
callq 0x21b8e
movq 0x48(%rsp), %rcx
cmpl (%rcx,%rbp,4), %eax
jle 0x22c2c
movl %eax, (%rcx,%rbp,4)
incq %rbp
jmp 0x22beb
incq %r12
addq $0x8, %r15
jmp 0x22be2
pushq $0x8
popq %r15
movq 0x28(%rsp), %r12
subq $0x1, %rbx
jb 0x22c89
movq (%r12), %rax
cmpb $0x1, (%rax,%r15)
jne 0x22c83
vmovq -0x8(%rax,%r15), %xmm0
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
vmovq %xmm0, %rax
btrq $0x3f, %rax
cmpq %rcx, %rax
je 0x22c83
callq 0x21b8e
cmpl 0xc(%rsp), %eax
jle 0x22c83
movl %eax, 0xc(%rsp)
addq $0x10, %r15
jmp 0x22c43
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x26aef
movq 0x8(%rax), %rax
cmpq $0x5, %rax
pushq $0x4
popq %rcx
leaq 0x80(%rsp), %rdx
cmovaeq %rax, %rcx
movq %rcx, (%rdx)
leaq 0x435146(%rip), %rdi # 0x457dfc
leaq 0x432b0b(%rip), %rsi # 0x4557c8
callq 0x26882
xorl %ebp, %ebp
pushq $0xa
popq %r12
leaq 0x435137(%rip), %r15 # 0x457e06
leaq 0x10(%rsp), %rbx
subq $0x1, %r13
jb 0x22d23
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rcx
movq 0x8(%rax,%rbp,8), %rax
movq %rax, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1dad8
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x48(%rsp), %rdx
addq %rbp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x268b3
addq $0x4, %rbp
jmp 0x22cd4
movq 0x30(%rsp), %rsi
leaq 0x4350df(%rip), %rdi # 0x457e0e
leaq 0xc(%rsp), %rdx
callq 0x268ee
movq 0x28(%rsp), %r12
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq 0x40(%rsp), %rbp
je 0x22fef
movq (%r14), %rax
imulq $0x28, %rbp, %rcx
movq (%rax,%rcx), %rdx
movq 0x8(%rax,%rcx), %rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x43508b(%rip), %rdi # 0x457dfc
leaq 0x10(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x26923
movq 0x48(%r14), %rax
vmovsd 0x431279(%rip), %xmm2 # 0x454008
vmovsd 0x434d21(%rip), %xmm0 # 0x457ab8
movq 0x20(%r14), %r13
xorl %ecx, %ecx
subq 0x18(%r14), %r13
imulq %r15, %rax
addq 0x30(%r14), %rax
sarq $0x5, %r13
cmpq %rcx, %r13
je 0x22de7
vmovq (%rax,%rcx,8), %xmm1
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
vmovq %xmm1, %rdx
btrq $0x3f, %rdx
cmpq %rsi, %rdx
je 0x22dda
vucomisd %xmm0, %xmm1
vminsd %xmm2, %xmm1, %xmm2
ja 0x22dde
vmovapd %xmm0, %xmm1
incq %rcx
vmovapd %xmm1, %xmm0
jmp 0x22dad
movq (%r12), %rax
movq %rbp, %rdx
shlq $0x4, %rdx
movq %rbp, 0x38(%rsp)
movq %rdx, 0x60(%rsp)
cmpb $0x0, 0x8(%rax,%rdx)
je 0x22e2d
addq %rdx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
vmovq (%rax), %xmm1
vmovq %xmm1, %rax
btrq $0x3f, %rax
cmpq %rcx, %rax
je 0x22e2d
vucomisd %xmm0, %xmm1
vminsd %xmm2, %xmm1, %xmm2
ja 0x22e31
vmovapd %xmm0, %xmm1
xorl %r12d, %r12d
xorl %ebp, %ebp
vmovsd %xmm2, 0x30(%rsp)
vmovsd %xmm1, 0x68(%rsp)
subq $0x1, %r13
jb 0x22f1e
movq 0x48(%r14), %rdx
imulq %r15, %rdx
addq 0x30(%r14), %rdx
vmovsd (%r12,%rdx), %xmm0
addq %r12, %rdx
vucomisd %xmm2, %xmm0
jne 0x22ea6
jp 0x22ea6
movq 0x48(%rsp), %rcx
movabsq $0x800000000001, %rax # imm = 0x800000000001
movb %bl, 0x18(%rsp)
movb %bl, 0x1c(%rsp)
movb %bl, 0x22(%rsp)
movq %rax, 0x10(%rsp)
movw $0x1, 0x20(%rsp)
addq %rbp, %rcx
leaq 0x10(%rsp), %rdi
leaq 0x434f77(%rip), %rsi # 0x457e16
callq 0x2695f
jmp 0x22f05
vucomisd %xmm1, %xmm0
jne 0x22eeb
jp 0x22eeb
movq 0x48(%rsp), %rcx
movabsq $0xff00000001, %rax # imm = 0xFF00000001
movb %bl, 0x18(%rsp)
movb %bl, 0x1c(%rsp)
movb %bl, 0x22(%rsp)
movq %rax, 0x10(%rsp)
movw $0x1, 0x20(%rsp)
addq %rbp, %rcx
leaq 0x10(%rsp), %rdi
leaq 0x434f32(%rip), %rsi # 0x457e16
callq 0x2695f
jmp 0x22f05
movq 0x48(%rsp), %rax
addq %rbp, %rax
leaq 0x434f1c(%rip), %rdi # 0x457e16
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2697a
vmovsd 0x30(%rsp), %xmm2
vmovsd 0x68(%rsp), %xmm1
addq $0x4, %rbp
addq $0x8, %r12
jmp 0x22e42
movq 0x28(%rsp), %r12
movq 0x60(%rsp), %rcx
movq (%r12), %rax
vmovsd (%rax,%rcx), %xmm0
leaq (%rax,%rcx), %rdx
vucomisd %xmm2, %xmm0
jne 0x22f7c
jp 0x22f7c
movabsq $0x800000000001, %rax # imm = 0x800000000001
movb %bl, 0x18(%rsp)
movb %bl, 0x1c(%rsp)
movb %bl, 0x22(%rsp)
movq %rax, 0x10(%rsp)
movw $0x1, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x434eab(%rip), %rsi # 0x457e16
leaq 0xc(%rsp), %rcx
callq 0x2695f
movq 0x38(%rsp), %rbp
jmp 0x22fd7
movq 0x38(%rsp), %rbp
vucomisd %xmm1, %xmm0
jne 0x22fc3
jp 0x22fc3
movabsq $0xff00000001, %rax # imm = 0xFF00000001
movb %bl, 0x18(%rsp)
movb %bl, 0x1c(%rsp)
movb %bl, 0x22(%rsp)
movq %rax, 0x10(%rsp)
movw $0x1, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x434e5f(%rip), %rsi # 0x457e16
leaq 0xc(%rsp), %rcx
callq 0x2695f
jmp 0x22fd7
movq %rdx, %rsi
leaq 0x434e49(%rip), %rdi # 0x457e16
leaq 0xc(%rsp), %rdx
callq 0x269ad
leaq 0x433949(%rip), %rdi # 0x456927
callq 0x269e0
incq %rbp
addq $0x8, %r15
jmp 0x22d45
leaq 0x48(%rsp), %rdi
callq 0x26a34
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
jmp 0x2301d
leaq 0x48(%rsp), %rdi
movq %rax, %rbx
callq 0x26a34
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/app/src/benchmark.cpp |
bench::push_back_model(std::basic_string_view<char, std::char_traits<char>>) | bool push_back_model(std::string_view name)
{
auto mdl = model::make_model(name);
if (!mdl)
return false;
models.emplace_back(*mdl);
return true;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x239ce
movb 0x28(%rbx), %bl
cmpb $0x1, %bl
jne 0x2332c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23a2c
leaq 0x8(%rsp), %rdi
callq 0x23d2a
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x23d2a
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/app/src/benchmark.cpp |
csv_whitespace::make_table() | static mask* make_table()
{
auto* v = new mask[table_size];
std::copy_n(classic_table(), table_size, v);
// Comma will be classified as whitespace.
v[static_cast<int>(',')] |= space;
// Space will be classified as character with graphic representation.
v[static_cast<int>(' ')] = graph;
return v;
} | pushq %rbx
movl $0x200, %edi # imm = 0x200
callq 0xb2a0
movq %rax, %rbx
callq 0xb4a0
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb070
orb $0x20, 0x59(%rbx)
movw $0xc04, 0x40(%rbx) # imm = 0xC04
movq %rbx, %rax
popq %rbx
retq
| /quesnel[P]baryonyx/app/src/benchmark.cpp |
void sort_on_value<__gnu_cxx::__normal_iterator<result*, std::vector<result, std::allocator<result>>>>(__gnu_cxx::__normal_iterator<result*, std::vector<result, std::allocator<result>>>, __gnu_cxx::__normal_iterator<result*, std::vector<result, std::allocator<result>>>, baryonyx::objective_function_type) | void
sort_on_value(Iterator first,
Iterator last,
baryonyx::objective_function_type type)
{
if (type == baryonyx::objective_function_type::minimize)
std::sort(first, last, [](const auto& lhs, const auto& rhs) {
if (is_valid(lhs.value)) {
if (is_valid(rhs.value)) {
return lhs.value < rhs.value;
} else {
return true;
}
} else {
return false;
}
});
else
std::sort(first, last, [](const auto& lhs, const auto& rhs) {
if (is_valid(lhs.value)) {
if (is_valid(rhs.value)) {
return lhs.value > rhs.value;
} else {
return true;
}
} else {
return false;
}
});
} | cmpl $0x1, %edx
jne 0x24ddf
jmp 0x245cd
| /quesnel[P]baryonyx/app/src/benchmark.cpp |
void fmt::v7::vprint<char [38], char>(_IO_FILE*, fmt::v7::text_style const&, char const (&) [38], fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<fmt::v7::type_identity<char>::type>, fmt::v7::type_identity<char>::type>>) | void vprint(std::FILE* f, const text_style& ts, const S& format,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, to_string_view(format), args);
buf.push_back(Char(0));
detail::fputs(buf.data(), f);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
leaq 0x30(%rsp), %rax
movq %rcx, %r15
leaq 0x6137a5(%rip), %rcx # 0x63a4b8
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %rbx
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
movq %rdx, %rdi
callq 0xf277
leaq 0x10(%rsp), %rdi
movq %rdx, %rcx
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0x20327
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xf9f2
leaq 0x10(%rsp), %r14
movq %rbx, %rsi
movq 0x8(%r14), %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0xf632
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x26d8e
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0xf632
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
void fmt::v7::vprint<char [65], char>(_IO_FILE*, fmt::v7::text_style const&, char const (&) [65], fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<fmt::v7::type_identity<char>::type>, fmt::v7::type_identity<char>::type>>) | void vprint(std::FILE* f, const text_style& ts, const S& format,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, to_string_view(format), args);
buf.push_back(Char(0));
detail::fputs(buf.data(), f);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
leaq 0x30(%rsp), %rax
movq %rcx, %r15
leaq 0x613546(%rip), %rcx # 0x63a4b8
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %rbx
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
movq %rdx, %rdi
callq 0xf277
leaq 0x10(%rsp), %rdi
movq %rdx, %rcx
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0x20327
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xf9f2
leaq 0x10(%rsp), %r14
movq %rbx, %rsi
movq 0x8(%r14), %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0xf632
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x26fed
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0xf632
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
baryonyx::split(baryonyx::context const&, baryonyx::problem const&, int) | std::tuple<problem, problem>
split(const context& ctx, const problem& pb, int variable_index_to_affect)
{
bx_expects(variable_index_to_affect >= 0 &&
variable_index_to_affect < length(pb.vars.values));
info(ctx,
" - Preprocessor starts split of variable {} (size: {})\n",
pb.vars.names[variable_index_to_affect],
to_string(memory_consumed_size(memory_consumed(pb))));
::preprocessor<problem> pp(ctx, pb);
return std::make_tuple(pp(variable_index_to_affect, true),
pp(variable_index_to_affect, false));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
testl %ecx, %ecx
js 0x2d0ee
movq 0xb0(%rdx), %rax
movl %ecx, %ebp
movq %rdx, %r14
subq 0xa8(%rdx), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
cmpl %ebp, %eax
jle 0x2d0ee
movl %ebp, %r12d
shlq $0x4, %r12
addq 0x90(%r14), %r12
movq %rdi, (%rsp)
movq %r14, %rdi
movq %rsi, %r15
callq 0x44ffe2
leaq 0x8(%rsp), %r13
movq %rax, %rsi
movq %r13, %rdi
callq 0x30b9b
leaq 0x18(%rsp), %rbx
movq %r13, %rsi
movq %rbx, %rdi
callq 0x44feb8
leaq 0x42bef1(%rip), %rsi # 0x458f35
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x30b76
leaq 0x18(%rsp), %rdi
callq 0xe956
leaq 0x110(%rsp), %rbx
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rdi
callq 0x2d146
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2d434
leaq 0x1f0(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2d434
movq (%rsp), %r15
leaq 0x18(%rsp), %rbx
leaq 0x1f0(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rdi
callq 0x30d26
movq %r14, %rdi
callq 0x27fb8
movq %rbx, %rdi
callq 0x27fb8
leaq 0x110(%rsp), %rdi
callq 0x2e2a8
movq %r15, %rax
addq $0x2e8, %rsp # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42b0e9(%rip), %rdi # 0x4581de
leaq 0x42bd84(%rip), %rsi # 0x458e80
leaq 0x42bdd0(%rip), %rdx # 0x458ed3
leaq 0x42be27(%rip), %rcx # 0x458f31
callq 0x2813f
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0x27fb8
jmp 0x2d121
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
callq 0x2e2a8
jmp 0x2d13d
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0xe956
movq %rbx, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::problem>::preprocessor(baryonyx::context const&, baryonyx::problem const&) | explicit preprocessor(const bx::context& ctx_, const Problem& pb_)
: ctx(ctx_)
, pb(pb_)
, equal_constraints(pb.equal_constraints.size())
, greater_constraints(pb.greater_constraints.size())
, less_constraints(pb.less_constraints.size())
, cache(pb.vars.values.size())
{
// The cache stores for each variable, all constraint where element
// variable is used.
for (int i = 0, e = bx::length(pb.equal_constraints); i != e; ++i)
for (const auto& elem : pb.equal_constraints[i].elements)
cache[elem.variable_index].in_equal_constraints.emplace_back(
i);
for (int i = 0, e = bx::length(pb.greater_constraints); i != e; ++i)
for (const auto& elem : pb.greater_constraints[i].elements)
cache[elem.variable_index].in_greater_constraints.emplace_back(
i);
for (int i = 0, e = bx::length(pb.less_constraints); i != e; ++i)
for (const auto& elem : pb.less_constraints[i].elements)
cache[elem.variable_index].in_less_constraints.emplace_back(i);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x40(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x48(%rdi), %r14
movq %rdi, %rbx
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
vmovups %xmm0, 0x20(%rdi)
movl $0x3f800000, 0x30(%rdi) # imm = 0x3F800000
vmovups %xmm0, 0x38(%rdi)
movq 0x50(%rdx), %rax
subq 0x48(%rdx), %rax
pushq $0x30
popq %r13
cqto
idivq %r13
leaq 0x3(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3140c
movq 0x8(%rbx), %rcx
leaq 0x60(%rbx), %r15
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
cqto
idivq %r13
leaq 0x2(%rsp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x3140c
movq 0x8(%rbx), %rcx
leaq 0x78(%rbx), %r12
movq 0x80(%rcx), %rax
subq 0x78(%rcx), %rax
cqto
idivq %r13
leaq 0x1(%rsp), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x3140c
movq 0x8(%rbx), %rcx
leaq 0x90(%rbx), %r13
movq %r12, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movq 0xb0(%rcx), %rax
subq 0xa8(%rcx), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movq %r13, %rdi
movq %rax, %rsi
callq 0x2fba4
vxorps %xmm0, %xmm0, %xmm0
leaq 0xc(%rsp), %rbp
leaq 0xa8(%rbx), %rax
vmovups %ymm0, 0xc0(%rbx)
vmovups %ymm0, 0xa8(%rbx)
andl $0x0, (%rbp)
movq %rax, 0x30(%rsp)
leaq 0xc8(%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x28(%rsp)
movq 0x50(%rcx), %rax
subq 0x48(%rcx), %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
movq %rax, %r14
xorl %eax, %eax
cmpl %r14d, %eax
je 0x2d2ca
movq 0x8(%rbx), %rcx
cltq
imulq $0x30, %rax, %rax
movq 0x48(%rcx), %rcx
movq 0x10(%rcx,%rax), %r12
movq 0x18(%rcx,%rax), %r15
cmpq %r15, %r12
je 0x2d2be
movslq 0x4(%r12), %rax
imulq $0x48, %rax, %rdi
addq (%r13), %rdi
movq %rbp, %rsi
vzeroupper
callq 0x31460
addq $0x8, %r12
jmp 0x2d29b
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
jmp 0x2d27e
leaq 0x8(%rsp), %rbp
andl $0x0, (%rbp)
movq 0x8(%rbx), %rcx
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
movq %rax, %r14
xorl %eax, %eax
cmpl %r14d, %eax
je 0x2d33d
movq 0x8(%rbx), %rcx
cltq
imulq $0x30, %rax, %rax
movq 0x60(%rcx), %rcx
movq 0x10(%rcx,%rax), %r12
movq 0x18(%rcx,%rax), %r15
cmpq %r15, %r12
je 0x2d331
movslq 0x4(%r12), %rax
movq (%r13), %rcx
imulq $0x48, %rax, %rax
leaq 0x18(%rcx,%rax), %rdi
movq %rbp, %rsi
vzeroupper
callq 0x31460
addq $0x8, %r12
jmp 0x2d309
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
jmp 0x2d2ec
leaq 0x4(%rsp), %rbp
andl $0x0, (%rbp)
movq 0x8(%rbx), %rcx
movq 0x80(%rcx), %rax
subq 0x78(%rcx), %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
movq %rax, %r14
xorl %eax, %eax
cmpl %r14d, %eax
je 0x2d3b2
movq 0x8(%rbx), %rcx
cltq
imulq $0x30, %rax, %rax
movq 0x78(%rcx), %rcx
movq 0x10(%rcx,%rax), %r15
movq 0x18(%rcx,%rax), %r12
cmpq %r12, %r15
je 0x2d3a6
movslq 0x4(%r15), %rax
movq (%r13), %rcx
imulq $0x48, %rax, %rax
leaq 0x30(%rcx,%rax), %rdi
movq %rbp, %rsi
vzeroupper
callq 0x31460
addq $0x8, %r15
jmp 0x2d37f
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
jmp 0x2d362
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
movq %rax, %r12
jmp 0x2d3fb
movq %rax, %r12
jmp 0x2d40f
movq %rax, %r12
jmp 0x2d417
movq %rax, %r12
jmp 0x2d41f
jmp 0x2d3dc
jmp 0x2d3dc
movq 0x28(%rsp), %rdi
movq %rax, %r12
callq 0x2fb2c
movq 0x30(%rsp), %rdi
callq 0x20206
movq %r13, %rdi
callq 0x2fb40
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %r14
movq 0x18(%rsp), %r15
callq 0x26a34
movq %r15, %rdi
callq 0x26a34
movq %r14, %rdi
callq 0x26a34
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x30e68
movq %r12, %rdi
callq 0xb3d0
nop
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::problem>::affects() | void affects()
{
while (!lifo.empty()) {
auto top = lifo.pop();
vars.emplace(top.index, top.value);
debug(ctx,
" - variable {} assigned to {}.\n",
pb.vars.names[top.index],
top.value);
for (int cst : cache[top.index].in_equal_constraints) {
if (equal_constraints[cst] <= 0)
continue;
--equal_constraints[cst];
if (equal_constraints[cst] == 1) {
debug(ctx,
" - equal constraint {} will be removed.\n",
pb.equal_constraints[cst].label);
auto v =
reduce_equal_constraint(pb.equal_constraints[cst]);
equal_constraints[cst] = 0;
if (std::get<0>(v) >= 0)
lifo.emplace(std::get<0>(v), std::get<1>(v));
}
}
for (int cst : cache[top.index].in_greater_constraints) {
if (greater_constraints[cst] <= 0)
continue;
--greater_constraints[cst];
if (greater_constraints[cst] == 1) {
debug(ctx,
" - greater constraint {} will be removed.\n",
pb.greater_constraints[cst].label);
auto v =
reduce_greater_constraint(pb.greater_constraints[cst]);
greater_constraints[cst] = 0;
if (std::get<0>(v) >= 0)
lifo.emplace(std::get<0>(v), std::get<1>(v));
}
}
for (int cst : cache[top.index].in_less_constraints) {
if (less_constraints[cst] <= 0)
continue;
--less_constraints[cst];
if (less_constraints[cst] == 1) {
debug(ctx,
" - less constraint {} will be removed.\n",
pb.less_constraints[cst].label);
auto v = reduce_less_constraint(pb.less_constraints[cst]);
less_constraints[cst] = 0;
if (std::get<0>(v) >= 0)
lifo.emplace(std::get<0>(v), std::get<1>(v));
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0xc8(%rdi), %rax
leaq 0x10(%rdi), %rcx
leaq 0x4c(%rsp), %rbp
movq %rdi, %rbx
movq %rax, 0x20(%rsp)
movq %rcx, 0x40(%rsp)
movq 0xc8(%rbx), %rax
cmpq 0xd0(%rbx), %rax
je 0x2ffbb
movq 0x20(%rsp), %rdi
callq 0x301e0
movq 0x40(%rsp), %rdi
movl %eax, 0x18(%rsp)
shrq $0x20, %rax
leaq 0x1c(%rsp), %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
movb %al, 0x1c(%rsp)
callq 0x31634
movslq 0x18(%rsp), %rdx
movq 0x8(%rbx), %rax
movq (%rbx), %rdi
leaq 0x429405(%rip), %rsi # 0x4590a4
movq %r14, %rcx
shlq $0x4, %rdx
addq 0x90(%rax), %rdx
callq 0x315ec
movslq 0x18(%rsp), %rax
movq 0x90(%rbx), %rcx
imulq $0x48, %rax, %rax
movq (%rcx,%rax), %r14
movq 0x8(%rcx,%rax), %r13
cmpq %r13, %r14
je 0x2fdb5
movslq (%r14), %r12
movq 0x48(%rbx), %rax
movl (%rax,%r12,4), %ecx
testl %ecx, %ecx
jle 0x2fdac
decl %ecx
movl %ecx, (%rax,%r12,4)
cmpl $0x1, %ecx
jne 0x2fdac
movq 0x8(%rbx), %rax
movq (%rbx), %rdi
imulq $0x30, %r12, %r15
leaq 0x4293bf(%rip), %rsi # 0x4590c7
movq 0x48(%rax), %rdx
addq %r15, %rdx
callq 0x31611
movq 0x8(%rbx), %rax
movq %rbp, %rdi
movq %rbx, %rsi
addq 0x48(%rax), %r15
movq %r15, %rdx
callq 0x30218
leaq 0xc(%rsp), %rax
leaq 0x10(%rsp), %rdx
leaq 0x14(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
callq 0x319f4
movl 0x10(%rsp), %ecx
testl %ecx, %ecx
js 0x2fda3
movl 0xc(%rsp), %eax
movl %ecx, %esi
cmpl %eax, 0x14(%rsp)
sete %dil
pushq $-0x1
popq %rdx
cmovel %edx, %esi
xorl %edx, %edx
testl %eax, %eax
sete %r8b
setne %al
cmovnel %ecx, %esi
orb %dil, %r8b
je 0x2ffca
movq 0x48(%rbx), %rcx
andl $0x0, (%rcx,%r12,4)
testl %esi, %esi
js 0x2fdac
movq 0x20(%rsp), %rdi
movb %al, %dl
callq 0x3002e
jmp 0x2fdac
movq 0x48(%rbx), %rax
andl $0x0, (%rax,%r12,4)
addq $0x4, %r14
jmp 0x2fccb
movslq 0x18(%rsp), %rax
movq 0x90(%rbx), %rcx
imulq $0x48, %rax, %rax
movq 0x18(%rcx,%rax), %r14
movq 0x20(%rcx,%rax), %r13
cmpq %r13, %r14
je 0x2feb9
movslq (%r14), %r12
movq 0x60(%rbx), %rax
movl (%rax,%r12,4), %ecx
testl %ecx, %ecx
jle 0x2feb0
decl %ecx
movl %ecx, (%rax,%r12,4)
cmpl $0x1, %ecx
jne 0x2feb0
movq 0x8(%rbx), %rax
movq (%rbx), %rdi
imulq $0x30, %r12, %r15
leaq 0x4292e9(%rip), %rsi # 0x4590f5
movq 0x60(%rax), %rdx
addq %r15, %rdx
callq 0x31611
movq 0x8(%rbx), %rax
movq %rbp, %rdi
movq %rbx, %rsi
addq 0x60(%rax), %r15
movq %r15, %rdx
callq 0x30218
leaq 0xc(%rsp), %rax
leaq 0x10(%rsp), %rdx
leaq 0x14(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
callq 0x319f4
movl 0x10(%rsp), %ecx
testl %ecx, %ecx
js 0x2fea7
movl 0xc(%rsp), %eax
movl %ecx, %esi
cmpl %eax, 0x14(%rsp)
setge %dil
pushq $-0x1
popq %rdx
cmovgel %edx, %esi
xorl %edx, %edx
testl %eax, %eax
setle %r8b
setg %al
cmovgl %ecx, %esi
orb %dil, %r8b
je 0x2ffeb
movq 0x60(%rbx), %rcx
andl $0x0, (%rcx,%r12,4)
testl %esi, %esi
js 0x2feb0
movq 0x20(%rsp), %rdi
movb %al, %dl
callq 0x3002e
jmp 0x2feb0
movq 0x60(%rbx), %rax
andl $0x0, (%rax,%r12,4)
addq $0x4, %r14
jmp 0x2fdcf
movslq 0x18(%rsp), %rax
movq 0x90(%rbx), %rcx
imulq $0x48, %rax, %rax
movq 0x30(%rcx,%rax), %r14
movq 0x38(%rcx,%rax), %r13
cmpq %r13, %r14
je 0x2fc4b
movslq (%r14), %r12
movq 0x78(%rbx), %rax
movl (%rax,%r12,4), %ecx
testl %ecx, %ecx
jle 0x2ffb2
decl %ecx
movl %ecx, (%rax,%r12,4)
cmpl $0x1, %ecx
jne 0x2ffb2
movq 0x8(%rbx), %rax
movq (%rbx), %rdi
imulq $0x30, %r12, %r15
leaq 0x429215(%rip), %rsi # 0x459125
movq 0x78(%rax), %rdx
addq %r15, %rdx
callq 0x31611
movq 0x8(%rbx), %rax
movq %rbp, %rdi
movq %rbx, %rsi
addq 0x78(%rax), %r15
movq %r15, %rdx
callq 0x30218
leaq 0xc(%rsp), %rax
leaq 0x10(%rsp), %rdx
leaq 0x14(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
callq 0x319f4
movl 0x10(%rsp), %ecx
testl %ecx, %ecx
js 0x2ffa9
movl 0xc(%rsp), %eax
movl %ecx, %esi
cmpl %eax, 0x14(%rsp)
setle %dl
pushq $-0x1
popq %rdi
cmovlel %edi, %esi
testl %eax, %eax
setns %dil
cmovsl %ecx, %esi
orb %dl, %dil
je 0x3000c
movq 0x78(%rbx), %rcx
andl $0x0, (%rcx,%r12,4)
testl %esi, %esi
js 0x2ffb2
movq 0x20(%rsp), %rdi
shrl $0x1f, %eax
movzbl %al, %edx
callq 0x3002e
jmp 0x2ffb2
movq 0x78(%rbx), %rax
andl $0x0, (%rax,%r12,4)
addq $0x4, %r14
jmp 0x2fed3
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42918e(%rip), %rdi # 0x45915f
leaq 0x42918f(%rip), %rsi # 0x459167
leaq 0x428ef4(%rip), %rdx # 0x458ed3
leaq 0x428490(%rip), %rcx # 0x458476
callq 0x2813f
leaq 0x42916d(%rip), %rdi # 0x45915f
leaq 0x42916e(%rip), %rsi # 0x459167
leaq 0x428ed3(%rip), %rdx # 0x458ed3
leaq 0x429189(%rip), %rcx # 0x459190
callq 0x2813f
leaq 0x42914c(%rip), %rdi # 0x45915f
leaq 0x42914d(%rip), %rsi # 0x459167
leaq 0x428eb2(%rip), %rdx # 0x458ed3
leaq 0x42916c(%rip), %rcx # 0x459194
callq 0x2813f
nop
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::pp_lifo::emplace(int, bool) | bool emplace(int variable, bool value)
{
auto it = std::find_if(
data.cbegin(), data.cend(), [&variable](const auto& elem) {
return elem.index == variable;
});
if (it != data.cend())
return false;
data.emplace_back(variable, value);
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rdi), %r14
movl %esi, %r12d
movq %rdi, %rbx
movq %rax, %r15
subq %r14, %r15
movq %r15, %rcx
sarq $0x5, %rcx
pushq $0x18
popq %rsi
xorl %r8d, %r8d
testq %rcx, %rcx
jle 0x30086
cmpl %r12d, -0x18(%r14,%rsi)
je 0x300a8
cmpl %r12d, -0x10(%r14,%rsi)
je 0x300b0
cmpl %r12d, -0x8(%r14,%rsi)
je 0x300bc
cmpl %r12d, (%r14,%rsi)
je 0x300c8
decq %rcx
addq $-0x20, %r8
addq $0x20, %rsi
jmp 0x30059
leaq (%r15,%r8), %rdi
movq %r14, %rcx
subq %r8, %rcx
sarq $0x3, %rdi
cmpq $0x3, %rdi
je 0x300d4
cmpq $0x2, %rdi
je 0x300e5
cmpq $0x1, %rdi
je 0x300ee
jmp 0x300fe
movq %r14, %rcx
subq %r8, %rcx
jmp 0x300f5
movq %r14, %rcx
subq %r8, %rcx
addq $0x8, %rcx
jmp 0x300f5
movq %r14, %rcx
subq %r8, %rcx
addq $0x10, %rcx
jmp 0x300f5
movq %r14, %rcx
subq %r8, %rcx
addq $0x18, %rcx
jmp 0x300f5
cmpl %r12d, -0x18(%r14,%rsi)
je 0x300f5
movq %r14, %rcx
subq %r8, %rcx
addq $0x8, %rcx
cmpl %r12d, (%rcx)
je 0x300f5
addq $0x8, %rcx
cmpl %r12d, (%rcx)
cmovneq %rax, %rcx
cmpq %rax, %rcx
jne 0x301c4
cmpq 0x10(%rbx), %rax
je 0x30117
movl %r12d, (%rax)
movb %dl, 0x4(%rax)
addq $0x8, %rax
movq %rax, 0x8(%rbx)
jmp 0x301c4
movabsq $0x7ffffffffffffff8, %rcx # imm = 0x7FFFFFFFFFFFFFF8
cmpq %rcx, %r15
je 0x301d3
movq %r15, %rbp
sarq $0x3, %rbp
cmpq %r14, %rax
pushq $0x1
popq %rax
cmovneq %rbp, %rax
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
leaq (%rax,%rbp), %rsi
cmpq %rcx, %rsi
cmovaeq %rcx, %rsi
addq %rbp, %rax
cmovbq %rcx, %rsi
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x30178
leaq (,%rsi,8), %rdi
movl %edx, %r13d
callq 0xb130
movl %r13d, %edx
movq %rax, %r13
jmp 0x3017b
xorl %r13d, %r13d
movl %r12d, (%r13,%rbp,8)
movb %dl, 0x4(%r13,%rbp,8)
testq %r15, %r15
jle 0x30198
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb140
movq 0x10(%rbx), %rsi
leaq 0x8(%r13,%r15), %r15
movq %r14, %rdi
subq %r14, %rsi
sarq $0x3, %rsi
callq 0x2fb94
movq (%rsp), %rax
movq %r13, (%rbx)
movq %r15, 0x8(%rbx)
leaq (%r13,%rax,8), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x425ad8(%rip), %rdi # 0x455cb2
callq 0xb3a0
nop
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::problem>::reduce(baryonyx::constraint const&) | auto reduce(const bx::constraint& constraint) -> std::tuple<int, int, int>
{
int constraint_result{ constraint.value };
int remaining_index{ -1 };
int factor;
int var_id;
for (int i = 0, e = bx::length(constraint.elements); i != e; ++i) {
// Searches if the variable is already affected and then use the
// value to update the value of the constraint.
auto it = vars.find(constraint.elements[i].variable_index);
if (it == vars.end()) {
bx_assert(remaining_index == -1);
remaining_index = i;
} else {
constraint_result +=
-1 * (constraint.elements[i].factor * it->second);
}
}
if (remaining_index >= 0) {
factor = constraint.elements[remaining_index].factor;
var_id = constraint.elements[remaining_index].variable_index;
} else {
factor = -1;
var_id = -1;
}
return std::make_tuple(factor, var_id, constraint_result);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdx), %rax
movl 0x28(%rdx), %ebp
movl $0x2003, %ecx # imm = 0x2003
movq %rsi, %r15
addq $0x10, %r15
movq %rdx, %r14
movq %rdi, 0x10(%rsp)
subq 0x10(%rdx), %rax
bextrq %rcx, %rax, %r12
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
pushq $0x4
popq %r13
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x30294
movq 0x10(%r14), %rsi
movq %r15, %rdi
addq %r13, %rsi
callq 0x31a0a
testq %rax, %rax
je 0x30280
movq 0x10(%r14), %rcx
movzbl 0xc(%rax), %eax
imull (%rcx,%rbx,8), %eax
subl %eax, %ebp
jmp 0x3028b
cmpl $-0x1, 0xc(%rsp)
jne 0x302cd
movl %ebx, 0xc(%rsp)
incq %rbx
addq $0x8, %r13
jmp 0x30257
movl 0xc(%rsp), %eax
testl %eax, %eax
js 0x302a9
movq 0x10(%r14), %rcx
movl %eax, %eax
vmovq (%rcx,%rax,8), %xmm0
jmp 0x302ad
vpcmpeqd %xmm0, %xmm0, %xmm0
movq 0x10(%rsp), %rax
vpshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movl %ebp, (%rax)
vmovq %xmm0, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x428e98(%rip), %rdi # 0x45916c
leaq 0x428e9b(%rip), %rsi # 0x459176
leaq 0x428bf1(%rip), %rdx # 0x458ed3
leaq 0x428ea3(%rip), %rcx # 0x45918c
callq 0x2813f
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::raw_problem>::reduce_equal_constraint(baryonyx::constraint const&) | auto reduce_equal_constraint(const bx::constraint& constraint)
-> std::tuple<int, bool>
{
int factor, variable, result;
std::tie(factor, variable, result) = reduce(constraint);
if (variable < 0)
return std::make_tuple(-1, false);
bool affect_0 = (factor * 0 == result);
bool affect_1 = (factor * 1 == result);
if (affect_0 && affect_1)
return std::make_tuple(-1, false);
if (affect_0)
return std::make_tuple(variable, false);
if (affect_1)
return std::make_tuple(variable, true);
bx_reach();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0xc(%rsp), %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x30948
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rcx
movq %rsp, %rax
movq %r14, %rsi
movq %rax, (%rdi)
movq %r15, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
callq 0x319f4
movl (%r15), %edx
testl %edx, %edx
js 0x3074a
movl (%rsp), %ecx
cmpl %ecx, 0x4(%rsp)
sete %sil
pushq $-0x1
popq %rax
cmovnel %edx, %eax
testl %ecx, %ecx
sete %dil
setne %cl
cmovnel %edx, %eax
orb %sil, %dil
jne 0x3074f
leaq 0x428a2f(%rip), %rdi # 0x45915f
leaq 0x428a30(%rip), %rsi # 0x459167
leaq 0x428795(%rip), %rdx # 0x458ed3
leaq 0x427d31(%rip), %rcx # 0x458476
callq 0x2813f
pushq $-0x1
popq %rax
xorl %ecx, %ecx
movb %cl, (%rbx)
movl %eax, 0x4(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::raw_problem>::constraints_exclude_copy(std::vector<std::pair<int, bool>, std::allocator<std::pair<int, bool>>> const&, std::vector<int, std::allocator<int>> const&, std::vector<baryonyx::constraint, std::allocator<baryonyx::constraint>> const&, std::vector<baryonyx::constraint, std::allocator<baryonyx::constraint>>&) const | void constraints_exclude_copy(
const std::vector<std::pair<int, bool>>& mapping,
const std::vector<int>& constraints_size,
const std::vector<bx::constraint>& constraints,
std::vector<bx::constraint>& copy) const
{
for (int i = 0, e = bx::length(constraints); i != e; ++i) {
// Remaining constraints with one element are undecidable (can be 0
// or 1) but useless in constraints (e.g. x <= 1) list. We remove
// it.
if (constraints_size[i] <= 1)
continue;
copy.emplace_back();
copy.back().id = constraints[i].id;
copy.back().label = constraints[i].label;
copy.back().value = constraints[i].value;
for (const auto& elem : constraints[i].elements) {
if (mapping[elem.variable_index].first >= 0) {
copy.back().elements.emplace_back(
elem.factor, mapping[elem.variable_index].first);
} else {
if (mapping[elem.variable_index].second == true) {
copy.back().value -= elem.factor;
}
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdx), %rax
movq %rcx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
movq %rdx, 0x8(%rsp)
subq (%rdx), %rax
pushq $0x30
popq %rcx
cqto
xorl %r15d, %r15d
idivq %rcx
movl %eax, %ebp
cmpq %rbp, %r15
je 0x30b67
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax,%r15,4)
jge 0x30ae7
incq %r15
jmp 0x30aca
movq %rbx, %rdi
callq 0x32b9e
movq 0x8(%rsp), %rdi
imulq $0x30, %r15, %rcx
movq 0x8(%rbx), %rsi
movq (%rdi), %rax
movl 0x2c(%rax,%rcx), %edx
movl %edx, -0x4(%rsi)
vmovups (%rax,%rcx), %xmm0
vmovups %xmm0, -0x30(%rsi)
movq (%rdi), %rax
movq 0x8(%rbx), %rsi
movl 0x28(%rax,%rcx), %edx
movl %edx, -0x8(%rsi)
movq 0x10(%rax,%rcx), %r13
movq 0x18(%rax,%rcx), %r14
cmpq %r14, %r13
je 0x30ae2
movslq 0x4(%r13), %rax
movq (%r12), %rcx
leaq (%rcx,%rax,8), %rdx
cmpl $0x0, (%rdx)
js 0x30b50
movq 0x8(%rbx), %rdi
movq %r13, %rsi
addq $-0x20, %rdi
callq 0x32bdc
jmp 0x30b61
cmpb $0x1, 0x4(%rdx)
jne 0x30b61
movl (%r13), %eax
movq 0x8(%rbx), %rcx
subl %eax, -0x8(%rcx)
addq $0x8, %r13
jmp 0x30b28
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
void write_constraints<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&) | void
write_constraints(FormatContext& ctx, const Problem& pb)
{
for (std::size_t i = 0, e = pb.equal_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.equal_constraints[i], " = ");
for (std::size_t i = 0, e = pb.greater_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.greater_constraints[i], " >= ");
for (std::size_t i = 0, e = pb.less_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.less_constraints[i], " <= ");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rsi), %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x48(%rsi), %rax
pushq $0x30
popq %r13
cqto
leaq 0x4289ee(%rip), %r12 # 0x45c30f
xorl %ebp, %ebp
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x3394a
movq 0x48(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
addq %rbp, %rdx
callq 0x33d5c
addq $0x30, %rbp
jmp 0x33929
movq 0x68(%rbx), %rax
leaq 0x425f18(%rip), %r12 # 0x45986d
xorl %ebp, %ebp
subq 0x60(%rbx), %rax
cqto
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x33984
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
addq %rbp, %rdx
callq 0x33d5c
addq $0x30, %rbp
jmp 0x33963
movq 0x80(%rbx), %rax
leaq 0x42d6c5(%rip), %r12 # 0x461057
subq 0x78(%rbx), %rax
cqto
idivq %r13
xorl %r13d, %r13d
movq %rax, %r15
subq $0x1, %r15
jb 0x339c2
movq 0x78(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
addq %r13, %rdx
callq 0x33d5c
addq $0x30, %r13
jmp 0x339a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_bounds<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&) | void
write_bounds(FormatContext& ctx, const Problem& p)
{
for (std::size_t i{ 0 }, e{ p.vars.names.size() }; i != e; ++i) {
if (p.vars.values[i].min != 0)
fmt::format_to(
ctx.out(), "{} >= {}\n", p.vars.names[i], p.vars.values[i].min);
if (p.vars.values[i].max != std::numeric_limits<int>::max())
fmt::format_to(
ctx.out(), "{} <= {}\n", p.vars.names[i], p.vars.values[i].max);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rsi), %r13
movq %rsi, %rbx
movq %rdi, %r14
subq 0x90(%rsi), %r13
sarq $0x4, %r13
pushq $0x4
popq %rbp
leaq 0x425e45(%rip), %r12 # 0x45987d
xorl %r15d, %r15d
subq $0x1, %r13
jb 0x33a9f
movq 0xa8(%rbx), %rcx
cmpl $0x0, -0x4(%rcx,%rbp)
je 0x33a70
movq 0x90(%rbx), %rdx
movq (%r14), %rdi
leaq -0x4(%rcx,%rbp), %rcx
movq %r12, %rsi
addq %r15, %rdx
callq 0x33f2f
movq 0xa8(%rbx), %rcx
cmpl $0x7fffffff, (%rcx,%rbp) # imm = 0x7FFFFFFF
je 0x33a95
movq 0x90(%rbx), %rdx
movq (%r14), %rdi
addq %rbp, %rcx
leaq 0x4330d6(%rip), %rsi # 0x466b63
addq %r15, %rdx
callq 0x33f2f
addq $0xc, %rbp
addq $0x10, %r15
jmp 0x33a3b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [5], std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [5], std::basic_string_view<char, std::char_traits<char>> const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
callq 0xf277
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0xd
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [8], double const&, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [8], double const&, std::basic_string_view<char, std::char_traits<char>> const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xda, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [10], double, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [10], double&&, std::basic_string_view<char, std::char_traits<char>> const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xda, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
void write_constraint<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem, baryonyx::constraint>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&, baryonyx::constraint const&, char const*) | void
write_constraint(FormatContext& ctx,
const Problem& p,
const Constraint& cst,
const char* separator)
{
if (!cst.label.empty())
fmt::format_to(ctx.out(), "{}: ", cst.label);
write_function_element(ctx, p, cst.elements);
fmt::format_to(ctx.out(), "{}{}\n", separator, cst.value);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdx)
je 0x33d8b
movq (%r14), %rdi
leaq 0x425aef(%rip), %rsi # 0x459872
movq %rbx, %rdx
callq 0x33aae
leaq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33dbf
movq (%r14), %rdi
addq $0x28, %rbx
leaq 0x425acf(%rip), %rsi # 0x459877
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x33e52
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>> const&) | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);
else if (elem.factor > 0)
fmt::format_to(ctx.out(),
"+ {} {}",
elem.factor,
p.vars.names[elem.variable_index]);
fmt::format_to(ctx.out(), " ");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %r12
leaq 0x42f96d(%rip), %r13 # 0x463745
leaq 0x425a66(%rip), %rbp # 0x459845
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r12, %r15
je 0x33e43
cmpl $0x0, (%r15)
js 0x33e11
je 0x33e32
movslq 0x4(%r15), %rcx
movq (%r14), %rdi
movq %rbp, %rsi
movq %r15, %rdx
shlq $0x4, %rcx
addq 0x90(%rbx), %rcx
callq 0x33ee2
jmp 0x33e32
movslq 0x4(%r15), %rcx
movq (%r14), %rdi
leaq 0x425a27(%rip), %rsi # 0x459846
movq %r15, %rdx
shlq $0x4, %rcx
addq 0x90(%rbx), %rcx
callq 0x33e95
movq (%r14), %rdi
movq %r13, %rsi
callq 0x33c03
addq $0x8, %r15
jmp 0x33de5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [6], char const*&, int const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [6], char const*&, int const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movl (%rcx), %ecx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0x1c
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [7], int const&, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [7], int const&, std::basic_string_view<char, std::char_traits<char>> const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl (%rdx), %eax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xd1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [8], int const&, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [8], int const&, std::basic_string_view<char, std::char_traits<char>> const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl (%rdx), %eax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xd1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, std::vector<baryonyx::objective_function_element, std::allocator<baryonyx::objective_function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&, std::vector<baryonyx::objective_function_element, std::allocator<baryonyx::objective_function_element>> const&) | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);
else if (elem.factor > 0)
fmt::format_to(ctx.out(),
"+ {} {}",
elem.factor,
p.vars.names[elem.variable_index]);
fmt::format_to(ctx.out(), " ");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %rbp
vxorpd %xmm1, %xmm1, %xmm1
leaq 0x42566e(%rip), %r12 # 0x459846
leaq 0x42f566(%rip), %r13 # 0x463745
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rbp, %r15
je 0x34250
vmovsd (%r15), %xmm0
vucomisd %xmm0, %xmm1
jbe 0x34214
movslq 0x8(%r15), %rcx
movq (%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
shlq $0x4, %rcx
addq 0x90(%rbx), %rcx
callq 0x33b67
jmp 0x3423b
vucomisd %xmm1, %xmm0
jbe 0x3423b
movslq 0x8(%r15), %rcx
movq (%r14), %rdi
leaq 0x42561d(%rip), %rsi # 0x459845
movq %r15, %rdx
shlq $0x4, %rcx
addq 0x90(%rbx), %rcx
callq 0x33bb5
movq (%r14), %rdi
movq %r13, %rsi
callq 0x33c03
addq $0x10, %r15
vxorpd %xmm1, %xmm1, %xmm1
jmp 0x341e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_constraints<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&) | void
write_constraints(FormatContext& ctx, const Problem& pb)
{
for (std::size_t i = 0, e = pb.equal_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.equal_constraints[i], " = ");
for (std::size_t i = 0, e = pb.greater_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.greater_constraints[i], " >= ");
for (std::size_t i = 0, e = pb.less_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.less_constraints[i], " <= ");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rsi), %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x48(%rsi), %rax
pushq $0x30
popq %r13
cqto
leaq 0x427fb8(%rip), %r12 # 0x45c30f
xorl %ebp, %ebp
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x34380
movq 0x48(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
addq %rbp, %rdx
callq 0x344aa
addq $0x30, %rbp
jmp 0x3435f
movq 0x68(%rbx), %rax
leaq 0x4254e2(%rip), %r12 # 0x45986d
xorl %ebp, %ebp
subq 0x60(%rbx), %rax
cqto
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x343ba
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
addq %rbp, %rdx
callq 0x344aa
addq $0x30, %rbp
jmp 0x34399
movq 0x80(%rbx), %rax
leaq 0x42cc8f(%rip), %r12 # 0x461057
subq 0x78(%rbx), %rax
cqto
idivq %r13
xorl %r13d, %r13d
movq %rax, %r15
subq $0x1, %r15
jb 0x343f8
movq 0x78(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
addq %r13, %rdx
callq 0x344aa
addq $0x30, %r13
jmp 0x343d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_bounds<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&) | void
write_bounds(FormatContext& ctx, const Problem& p)
{
for (std::size_t i{ 0 }, e{ p.vars.names.size() }; i != e; ++i) {
if (p.vars.values[i].min != 0)
fmt::format_to(
ctx.out(), "{} >= {}\n", p.vars.names[i], p.vars.values[i].min);
if (p.vars.values[i].max != std::numeric_limits<int>::max())
fmt::format_to(
ctx.out(), "{} <= {}\n", p.vars.names[i], p.vars.values[i].max);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rsi), %r13
movq %rsi, %rbx
movq %rdi, %r14
subq 0x90(%rsi), %r13
sarq $0x4, %r13
pushq $0x4
popq %rbp
leaq 0x425449(%rip), %r12 # 0x45987d
xorl %r15d, %r15d
subq $0x1, %r13
jb 0x3449b
movq 0xa8(%rbx), %rcx
cmpl $0x0, -0x4(%rcx,%rbp)
je 0x3446c
movq 0x90(%rbx), %rdx
movq (%r14), %rdi
leaq -0x4(%rcx,%rbp), %rcx
movq %r12, %rsi
addq %r15, %rdx
callq 0x33f2f
movq 0xa8(%rbx), %rcx
cmpl $0x7fffffff, (%rcx,%rbp) # imm = 0x7FFFFFFF
je 0x34491
movq 0x90(%rbx), %rdx
movq (%r14), %rdi
addq %rbp, %rcx
leaq 0x4326da(%rip), %rsi # 0x466b63
addq %r15, %rdx
callq 0x33f2f
addq $0xc, %rbp
addq $0x10, %r15
jmp 0x34437
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_constraint<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, baryonyx::constraint>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&, baryonyx::constraint const&, char const*) | void
write_constraint(FormatContext& ctx,
const Problem& p,
const Constraint& cst,
const char* separator)
{
if (!cst.label.empty())
fmt::format_to(ctx.out(), "{}: ", cst.label);
write_function_element(ctx, p, cst.elements);
fmt::format_to(ctx.out(), "{}{}\n", separator, cst.value);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdx)
je 0x344d9
movq (%r14), %rdi
leaq 0x4253a1(%rip), %rsi # 0x459872
movq %rbx, %rdx
callq 0x33aae
leaq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3450d
movq (%r14), %rdi
addq $0x28, %rbx
leaq 0x425381(%rip), %rsi # 0x459877
leaq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x33e52
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>> const&) | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);
else if (elem.factor > 0)
fmt::format_to(ctx.out(),
"+ {} {}",
elem.factor,
p.vars.names[elem.variable_index]);
fmt::format_to(ctx.out(), " ");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %r12
leaq 0x42f21f(%rip), %r13 # 0x463745
leaq 0x425318(%rip), %rbp # 0x459845
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r12, %r15
je 0x34591
cmpl $0x0, (%r15)
js 0x3455f
je 0x34580
movslq 0x4(%r15), %rcx
movq (%r14), %rdi
movq %rbp, %rsi
movq %r15, %rdx
shlq $0x4, %rcx
addq 0x90(%rbx), %rcx
callq 0x33ee2
jmp 0x34580
movslq 0x4(%r15), %rcx
movq (%r14), %rdi
leaq 0x4252d9(%rip), %rsi # 0x459846
movq %r15, %rdx
shlq $0x4, %rcx
addq 0x90(%rbx), %rcx
callq 0x33e95
movq (%r14), %rdi
movq %r13, %rsi
callq 0x33c03
addq $0x8, %r15
jmp 0x34533
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /quesnel[P]baryonyx/lib/src/problem.hpp |
baryonyx::itm::select_float(baryonyx::context const&, baryonyx::problem const&, bool) | static result
select_float(const context& ctx, const problem& pb, bool is_optimization)
{
const auto f = static_cast<int>(ctx.parameters.float_type);
if (f == 0)
return select_mode<float_sel<0>>(ctx, pb, is_optimization);
else if (f == 1)
return select_mode<float_sel<1>>(ctx, pb, is_optimization);
else
return select_mode<float_sel<2>>(ctx, pb, is_optimization);
} | pushq %rbx
movq %rdi, %rbx
movl 0xd0(%rsi), %r9d
movl 0xf0(%rdx), %r8d
movq 0x28(%rdx), %rax
movq 0x30(%rdx), %rdi
cmpl $0x1, %r9d
je 0x3461e
testl %r9d, %r9d
jne 0x34641
testl %r8d, %r8d
je 0x34664
cmpq %rdi, %rax
je 0x346ba
movq %rbx, %rdi
testb %cl, %cl
je 0x346ea
callq 0x58425
jmp 0x34766
testl %r8d, %r8d
je 0x34682
cmpq %rdi, %rax
je 0x346cb
movq %rbx, %rdi
testb %cl, %cl
je 0x346f1
callq 0x80dfb
jmp 0x34766
testl %r8d, %r8d
je 0x346a0
cmpq %rdi, %rax
je 0x346dc
movq %rbx, %rdi
testb %cl, %cl
je 0x346f8
callq 0xaaa65
jmp 0x34766
cmpq %rdi, %rax
je 0x346ff
movq %rbx, %rdi
testb %cl, %cl
je 0x34729
callq 0x43c33
jmp 0x34766
cmpq %rdi, %rax
je 0x3470d
movq %rbx, %rdi
testb %cl, %cl
je 0x34737
callq 0x6cba5
jmp 0x34766
cmpq %rdi, %rax
je 0x3471b
movq %rbx, %rdi
testb %cl, %cl
je 0x34745
callq 0x95b8b
jmp 0x34766
movq %rbx, %rdi
testb %cl, %cl
je 0x34730
callq 0x4e9ad
jmp 0x34766
movq %rbx, %rdi
testb %cl, %cl
je 0x3473e
callq 0x77815
jmp 0x34766
movq %rbx, %rdi
testb %cl, %cl
je 0x3474c
callq 0xa0e3f
jmp 0x34766
callq 0x58a8e
jmp 0x34766
callq 0x81464
jmp 0x34766
callq 0xab0ce
jmp 0x34766
movq %rbx, %rdi
testb %cl, %cl
je 0x34753
callq 0x34908
jmp 0x34766
movq %rbx, %rdi
testb %cl, %cl
je 0x3475a
callq 0x61c7b
jmp 0x34766
movq %rbx, %rdi
testb %cl, %cl
je 0x34761
callq 0x8a43b
jmp 0x34766
callq 0x4429c
jmp 0x34766
callq 0x4f00a
jmp 0x34766
callq 0x6d20e
jmp 0x34766
callq 0x77e72
jmp 0x34766
callq 0x961f4
jmp 0x34766
callq 0xa149c
jmp 0x34766
callq 0x34f65
jmp 0x34766
callq 0x622d8
jmp 0x34766
callq 0x8aa98
movq %rbx, %rax
popq %rbx
retq
| /quesnel[P]baryonyx/lib/src/random-solver.cpp |
baryonyx::result baryonyx::itm::optimize_problem<baryonyx::itm::solver_random_inequalities_101coeff<float, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<float>>, float, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<float>>(baryonyx::context const&, baryonyx::problem const&) | inline result
optimize_problem(const context& ctx, const problem& pb)
{
result r;
if (ctx.start)
ctx.start(ctx.parameters);
auto constraints{ make_merged_constraints(ctx, pb) };
if (constraints.empty() || pb.vars.values.empty()) {
r.status = result_status::success;
r.solutions.resize(1);
r.solutions.back().value = pb.objective.value;
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
return r;
}
random_engine rng(init_random_generator_seed(ctx));
auto variables = length(pb.vars.values);
auto cost = Cost(pb.objective, variables);
auto cost_constant = pb.objective.value;
const auto thread = get_thread_number(ctx);
std::vector<optimize_functor<Solver, Float, Mode, Cost>> functors;
std::vector<std::thread> pool(thread);
best_solution_recorder<Cost, Float, Mode> best_recorder(
rng,
thread,
cost,
cost_constant,
variables,
constraints,
ctx.parameters.init_population_size);
auto seeds = generate_seed(rng, thread);
std::atomic_bool stop_task;
stop_task.store(false);
for (unsigned i = 0u; i != thread; ++i)
functors.emplace_back(ctx, i, seeds[i]);
for (unsigned i = 0u; i != thread; ++i)
pool[i] = std::thread(std::ref(functors[i]),
std::ref(stop_task),
std::ref(best_recorder),
std::cref(constraints),
variables,
std::cref(cost),
cost_constant);
const auto start = std::chrono::steady_clock::now();
auto end = start;
do {
std::this_thread::sleep_for(std::chrono::seconds{ 1L });
if (ctx.update) {
auto call_number = 0L;
for (auto i = 0u; i != thread; ++i)
call_number += functors[i].m_call_number;
int constraints_remaining;
long int loop;
double value;
double duration;
best_recorder.get_best(
constraints_remaining, value, duration, loop);
ctx.update(
constraints_remaining, value, loop, duration, call_number);
}
end = std::chrono::steady_clock::now();
} while (!is_time_limit(ctx.parameters.time_limit, start, end));
stop_task.store(true);
for (auto& t : pool)
t.join();
r.strings = pb.strings;
r.affected_vars = pb.affected_vars;
r.variable_name = pb.vars.names;
r.variables = variables;
r.constraints = length(constraints);
const auto& first = best_recorder.get_best(0);
if (!first.is_solution())
r.status = result_status::time_limit_reached;
else
r.status = result_status::success;
r.duration = first.duration;
r.loop = first.loop;
r.remaining_constraints = first.remaining_constraints;
switch (ctx.parameters.storage) {
case solver_parameters::storage_type::one: {
r.solutions.resize(1);
convert(first, r.solutions[0], variables);
} break;
case solver_parameters::storage_type::bound: {
r.solutions.resize(2);
convert(first, r.solutions[0], variables);
convert(best_recorder.get_worst(), r.solutions[1], variables);
} break;
case solver_parameters::storage_type::five: {
r.solutions.resize(5);
for (int i = 0; i != 5; ++i)
convert(best_recorder.get_best(i), r.solutions[i], variables);
} break;
}
best_recorder.show_population(ctx);
if (ctx.finish)
ctx.finish(r);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
vxorpd %xmm0, %xmm0, %xmm0
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa0(%rdi)
cmpq $0x0, 0x128(%rsi)
je 0x3496e
leaq 0x118(%r15), %rdi
movq %r15, %rsi
vzeroupper
callq 0x3527e
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
vzeroupper
callq 0x450078
movq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x34aca
movq 0xa8(%r13), %rax
cmpq 0xb0(%r13), %rax
je 0x34aca
movq %r15, %rdi
callq 0x353ba
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, 0x40(%rsp)
movq 0xb0(%r13), %rax
subq 0xa8(%r13), %rax
pushq $0xc
popq %rcx
cqto
leaq 0x10(%r13), %rsi
idivq %rcx
movl %eax, 0x4(%rsp)
leaq 0x60(%rsp), %rdi
movl %eax, %edx
movq %r12, 0x10(%rsp)
callq 0x353d2
vmovsd 0x40(%r13), %xmm0
vmovsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0x35447
andq $0x0, 0x80(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movl %eax, %ebp
vmovapd %xmm0, 0x70(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
movq %rbp, %rsi
callq 0x35462
vmovsd 0x38(%rsp), %xmm0
movl 0xc4(%r15), %eax
movl 0x4(%rsp), %r8d
subq $0x8, %rsp
movl %ebp, %edx
leaq 0xd0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %r9
pushq %rax
callq 0x354b6
popq %rax
popq %rcx
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl %ebp, %edx
callq 0x3551c
xorl %eax, %eax
movb %al, 0x3(%rsp)
xorl %ecx, %ecx
leaq 0x70(%rsp), %rbx
leaq 0x8(%rsp), %r14
xchgb %cl, 0x3(%rsp)
leaq 0x90(%r13), %rcx
movq %rcx, 0x98(%rsp)
movl %eax, 0x8(%rsp)
cmpl %ebp, %eax
je 0x34b25
movl %eax, %ecx
shlq $0x3, %rcx
addq 0x30(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x355d8
movl 0x8(%rsp), %eax
incl %eax
jmp 0x34aa1
andl $0x0, 0xa0(%r12)
leaq 0x68(%r12), %rdi
pushq $0x1
popq %rsi
callq 0x35292
vmovsd 0x40(%r13), %xmm0
movq 0x70(%r12), %rax
vmovsd %xmm0, -0x8(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x31d28
leaq 0xc0(%r13), %rsi
leaq 0x20(%r12), %rdi
callq 0x352c2
addq $0x90, %r13
leaq 0x50(%r12), %rdi
movq %r13, %rsi
callq 0x352ec
jmp 0x34eba
movq %r13, 0x90(%rsp)
movq %r15, %r13
leaq 0x8(%rsp), %r15
leaq 0xa8(%rsp), %r14
leaq 0x4(%rsp), %rbx
xorl %r12d, %r12d
cmpq %rbp, %r12
je 0x34be6
imulq $0xc0, %r12, %rax
addq 0x70(%rsp), %rax
leaq 0x3(%rsp), %r10
leaq 0xc8(%rsp), %r11
movq %r10, 0x20(%rsp)
leaq 0x48(%rsp), %r10
movq %r11, 0x18(%rsp)
movq %r10, 0xa8(%rsp)
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rax
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
pushq %rax
leaq 0xa8(%rsp), %rax
pushq %rax
callq 0x35624
popq %rax
popq %rcx
leaq (,%r12,8), %rdi
addq 0xb0(%rsp), %rdi
movq %r15, %rsi
callq 0x356d6
movq %r15, %rdi
callq 0x356f0
incq %r12
jmp 0x34b45
callq 0xb5a0
imulq $0xc0, %rbp, %r15
leaq 0x138(%r13), %r12
leaq 0x8(%rsp), %rbp
movq %rax, %rbx
movq $0x1, 0x8(%rsp)
movq %rbp, %rdi
callq 0x356fd
cmpq $0x0, 0x148(%r13)
je 0x34c7b
movq 0x70(%rsp), %rax
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpq %rcx, %r15
je 0x34c3c
addq 0xb0(%rax,%rcx), %r14
addq $0xc0, %rcx
jmp 0x34c26
leaq 0xd0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %r8
callq 0x412e4
vmovsd 0x28(%rsp), %xmm0
vmovsd 0x20(%rsp), %xmm1
movq 0x8(%rsp), %rdx
movl 0x18(%rsp), %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x35736
callq 0xb5a0
vmovsd (%r13), %xmm0
subq %rbx, %rax
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm0, %xmm1
vcvtsi2sd %rax, %xmm2, %xmm1
vdivsd 0x424de2(%rip), %xmm1, %xmm1 # 0x459a80
jae 0x34c01
vucomisd %xmm0, %xmm1
jbe 0x34c01
movb $0x1, %al
xchgb %al, 0x3(%rsp)
movq 0xb0(%rsp), %rbx
movq 0xb8(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r14, %rbx
je 0x34cdc
movq %rbx, %rdi
callq 0xb1a0
addq $0x8, %rbx
jmp 0x34cc9
movq 0x90(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31d28
addq $0xc0, %rbx
leaq 0x20(%r12), %rdi
movq %rbx, %rsi
callq 0x352c2
leaq 0x50(%r12), %rdi
movq 0x98(%rsp), %rsi
callq 0x352ec
movl 0x4(%rsp), %eax
movl %eax, 0x90(%r12)
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
pushq $0x28
popq %rcx
cqto
xorl %esi, %esi
idivq %rcx
movq 0x108(%rsp), %rdi
movq 0x120(%rsp), %rcx
movl %eax, 0x94(%r12)
movslq (%rdi), %rax
imulq $0x38, %rax, %rax
movl 0x30(%rcx,%rax), %edx
leaq (%rcx,%rax), %rbx
testl %edx, %edx
setne %sil
leal (%rsi,%rsi,2), %esi
movl %esi, 0xa0(%r12)
vmovsd 0x18(%rcx,%rax), %xmm0
vmovsd %xmm0, 0x80(%r12)
movq 0x28(%rcx,%rax), %rax
movq %rax, 0x88(%r12)
movl %edx, 0x98(%r12)
movl 0xe8(%r13), %eax
testl %eax, %eax
je 0x34e37
cmpl $0x1, %eax
je 0x34dff
cmpl $0x2, %eax
jne 0x34e56
leaq 0x68(%r12), %rbx
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x35292
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x34e56
movq 0x108(%rsp), %rax
movq (%rbx), %rsi
movl 0x4(%rsp), %edx
movslq (%rax,%r15,4), %rax
addq %r14, %rsi
imulq $0x38, %rax, %rdi
addq 0x120(%rsp), %rdi
callq 0x35781
incq %r15
addq $0x20, %r14
jmp 0x34dc5
leaq 0x68(%r12), %r14
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x35292
movl 0x4(%rsp), %edx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x35781
leaq 0xd0(%rsp), %rdi
callq 0x41466
movq (%r14), %rsi
movq %rax, %rbx
addq $0x20, %rsi
jmp 0x34e4a
leaq 0x68(%r12), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x35292
movq (%r14), %rsi
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x35781
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x357d6
cmpq $0x0, 0x168(%r13)
je 0x34e82
addq $0x158, %r13 # imm = 0x158
movq %r13, %rdi
movq %r12, %rsi
callq 0x357ea
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xc8(%rsp), %rdi
callq 0x35818
leaq 0xb0(%rsp), %rdi
callq 0x35836
leaq 0x70(%rsp), %rdi
callq 0x41636
leaq 0x68(%rsp), %rdi
callq 0x35c1a
leaq 0x48(%rsp), %rdi
callq 0x35858
movq %r12, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x34f1b
movq %rax, %rbx
jmp 0x34f28
movq %rax, %rbx
jmp 0x34f35
jmp 0x34eff
jmp 0x34ef0
jmp 0x34f0e
jmp 0x34f0e
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x34f53
movq %r12, 0x10(%rsp)
movq %rax, %rbx
jmp 0x34f49
jmp 0x34f0e
jmp 0x34f0e
jmp 0x34f0e
jmp 0x34f0e
jmp 0x34f0e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x357fe
leaq 0xc8(%rsp), %rdi
callq 0x35818
leaq 0xb0(%rsp), %rdi
callq 0x35836
leaq 0x70(%rsp), %rdi
callq 0x41636
leaq 0x68(%rsp), %rdi
callq 0x35c1a
leaq 0x48(%rsp), %rdi
callq 0x35858
movq 0x10(%rsp), %rdi
callq 0xea60
movq %rbx, %rdi
callq 0xb3d0
| /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.