SYMBOL INDEX (869 symbols across 92 files)

FILE: cmake/elf_to_size_coverage.py
  function parse_args (line 11) | def parse_args(args):
  class Generator (line 23) | class Generator:
    method __init__ (line 24) | def __init__(self, size_tool, base_file, out):
    method generate (line 33) | def generate(self, file: Path):
    method _get_size (line 50) | def _get_size(self, file: Path):
  function run (line 61) | def run():

FILE: include/emio/buffer.hpp
  type emio (line 24) | namespace emio {
    class buffer (line 33) | class buffer {
      method buffer (line 35) | constexpr buffer(const buffer& other) = delete;
      method buffer (line 36) | constexpr buffer(buffer&& other) = delete;
      method buffer (line 37) | constexpr buffer& operator=(const buffer& other) = delete;
      method buffer (line 38) | constexpr buffer& operator=(buffer&& other) = delete;
      method get_write_area_of (line 46) | constexpr result<std::span<char>> get_write_area_of(size_t size) noe...
      method get_write_area_of_max (line 62) | constexpr result<std::span<char>> get_write_area_of_max(size_t size)...
      type fixed_size (line 85) | enum class fixed_size : bool { no, yes }
      method buffer (line 91) | constexpr explicit buffer(fixed_size fixed = fixed_size::no) noexcep...
      method request_write_area (line 99) | virtual constexpr result<std::span<char>> request_write_area(const s...
      method set_write_area (line 109) | constexpr void set_write_area(const std::span<char> area) noexcept {
      method get_used_count (line 118) | [[nodiscard]] constexpr size_t get_used_count() const noexcept {
    class memory_buffer (line 133) | class memory_buffer final : public buffer {
      method memory_buffer (line 138) | constexpr memory_buffer() noexcept : memory_buffer{0} {}
      method memory_buffer (line 144) | constexpr explicit memory_buffer(const size_t capacity) noexcept {
      method memory_buffer (line 149) | constexpr memory_buffer(const memory_buffer& other)
      method memory_buffer (line 154) | constexpr memory_buffer(memory_buffer&& other) noexcept
      method memory_buffer (line 160) | constexpr memory_buffer& operator=(const memory_buffer& other) {
      method memory_buffer (line 171) | constexpr memory_buffer& operator=(memory_buffer&& other) noexcept {
      method view (line 189) | [[nodiscard]] constexpr std::string_view view() const noexcept {
      method str (line 198) | [[nodiscard]] std::string str() const {
      method reset (line 206) | constexpr void reset() noexcept {
      method capacity (line 216) | [[nodiscard]] constexpr size_t capacity() const noexcept {
      method request_write_area (line 221) | constexpr result<std::span<char>> request_write_area(const size_t us...
    class span_buffer (line 238) | class span_buffer : public buffer {
      method span_buffer (line 243) | constexpr span_buffer() : buffer{fixed_size::yes} {}
      method span_buffer (line 249) | constexpr explicit span_buffer(const std::span<char> span) noexcept ...
      method span_buffer (line 253) | constexpr span_buffer(const span_buffer& other) : buffer{fixed_size:...
      method span_buffer (line 259) | constexpr span_buffer(span_buffer&& other) noexcept : span_buffer{st...
      method span_buffer (line 261) | constexpr span_buffer& operator=(const span_buffer& other) {
      method span_buffer (line 272) | constexpr span_buffer& operator=(span_buffer&& other) noexcept {
      method view (line 283) | [[nodiscard]] constexpr std::string_view view() const noexcept {
      method str (line 292) | [[nodiscard]] std::string str() const {
      method reset (line 300) | constexpr void reset() noexcept {
      method capacity (line 308) | [[nodiscard]] constexpr size_t capacity() const noexcept {
    class static_buffer (line 324) | class static_buffer final : private std::array<char, StorageSize>, pub...
      method static_buffer (line 329) | constexpr static_buffer() noexcept : span_buffer{std::span{*this}} {}
      method static_buffer (line 331) | constexpr static_buffer(const static_buffer& other) : static_buffer() {
      method static_buffer (line 337) | constexpr static_buffer(static_buffer&& other) noexcept : static_buf...
      method static_buffer (line 339) | constexpr static_buffer& operator=(const static_buffer& other) {
      method static_buffer (line 350) | constexpr static_buffer& operator=(static_buffer&& other) noexcept {
    type detail (line 361) | namespace detail {
      function Container (line 365) | Container& get_container(std::back_insert_iterator<Container> it) no...
      type get_value_type (line 376) | struct get_value_type {
      type get_value_type<std::back_insert_iterator<Container>> (line 381) | struct get_value_type<std::back_insert_iterator<Container>> {
      type get_value_type<std::ostreambuf_iterator<Char, Traits>> (line 387) | struct get_value_type<std::ostreambuf_iterator<Char, Traits>> {
      function copy_str (line 396) | constexpr auto copy_str(InputIt it, InputIt end, OutputIt out) -> Ou...
      class counting_buffer (line 709) | class counting_buffer final : public buffer {
        method counting_buffer (line 712) | constexpr counting_buffer() noexcept = default;
        method counting_buffer (line 713) | constexpr counting_buffer(const counting_buffer&) = delete;
        method counting_buffer (line 714) | constexpr counting_buffer(counting_buffer&&) noexcept = delete;
        method counting_buffer (line 715) | constexpr counting_buffer& operator=(const counting_buffer&) = del...
        method counting_buffer (line 716) | constexpr counting_buffer& operator=(counting_buffer&&) noexcept =...
        method count (line 723) | [[nodiscard]] constexpr size_t count() const noexcept {
        method request_write_area (line 728) | constexpr result<std::span<char>> request_write_area(const size_t ...
    class iterator_buffer (line 409) | class iterator_buffer
    class iterator_buffer<Iterator, CacheSize> (line 419) | class iterator_buffer<Iterator, CacheSize> final : public buffer {
      method iterator_buffer (line 426) | constexpr explicit iterator_buffer(Iterator it) noexcept : it_{it} {
      method iterator_buffer (line 430) | iterator_buffer(const iterator_buffer&) = delete;
      method iterator_buffer (line 431) | iterator_buffer(iterator_buffer&&) = delete;
      method iterator_buffer (line 432) | iterator_buffer& operator=(const iterator_buffer&) = delete;
      method iterator_buffer (line 433) | iterator_buffer& operator=(iterator_buffer&&) = delete;
      method flush (line 440) | constexpr result<void> flush() noexcept {
      method Iterator (line 450) | constexpr Iterator out() noexcept {
      method request_write_area (line 456) | constexpr result<std::span<char>> request_write_area(const size_t /*...
    class iterator_buffer<OutputPtr*> (line 478) | class iterator_buffer<OutputPtr*> final : public buffer {
      method iterator_buffer (line 484) | constexpr explicit iterator_buffer(OutputPtr* ptr) noexcept : ptr_{p...
      method iterator_buffer (line 488) | iterator_buffer(const iterator_buffer&) = delete;
      method iterator_buffer (line 489) | iterator_buffer(iterator_buffer&&) = delete;
      method iterator_buffer (line 490) | iterator_buffer& operator=(const iterator_buffer&) = delete;
      method iterator_buffer (line 491) | iterator_buffer& operator=(iterator_buffer&&) = delete;
      method flush (line 498) | constexpr result<void> flush() noexcept {
      method OutputPtr (line 507) | constexpr OutputPtr* out() noexcept {
    class iterator_buffer<std::back_insert_iterator<Container>, Capacity> (line 522) | class iterator_buffer<std::back_insert_iterator<Container>, Capacity> ...
      method iterator_buffer (line 528) | constexpr explicit iterator_buffer(std::back_insert_iterator<Contain...
      method iterator_buffer (line 533) | iterator_buffer(const iterator_buffer&) = delete;
      method iterator_buffer (line 534) | iterator_buffer(iterator_buffer&&) = delete;
      method iterator_buffer (line 535) | iterator_buffer& operator=(const iterator_buffer&) = delete;
      method iterator_buffer (line 536) | iterator_buffer& operator=(iterator_buffer&&) = delete;
      method flush (line 543) | constexpr result<void> flush() noexcept {
      method out (line 552) | constexpr std::back_insert_iterator<Container> out() noexcept {
      method request_write_area (line 558) | constexpr result<std::span<char>> request_write_area(const size_t us...
    class file_buffer (line 580) | class file_buffer final : public buffer {
      method file_buffer (line 587) | constexpr explicit file_buffer(std::FILE* file) noexcept : file_{fil...
      method file_buffer (line 591) | file_buffer(const file_buffer&) = delete;
      method file_buffer (line 592) | file_buffer(file_buffer&&) = delete;
      method file_buffer (line 593) | file_buffer& operator=(const file_buffer&) = delete;
      method file_buffer (line 594) | file_buffer& operator=(file_buffer&&) = delete;
      method flush (line 601) | result<void> flush() noexcept {
      method reset (line 613) | constexpr void reset() noexcept {
      method request_write_area (line 619) | result<std::span<char>> request_write_area(const size_t /*used*/, co...
    class truncating_buffer (line 640) | class truncating_buffer final : public buffer {
      method truncating_buffer (line 648) | constexpr explicit truncating_buffer(buffer& primary, size_t limit) ...
      method truncating_buffer (line 652) | truncating_buffer(const truncating_buffer&) = delete;
      method truncating_buffer (line 653) | truncating_buffer(truncating_buffer&&) = delete;
      method truncating_buffer (line 654) | truncating_buffer& operator=(const truncating_buffer&) = delete;
      method truncating_buffer (line 655) | truncating_buffer& operator=(truncating_buffer&&) = delete;
      method count (line 662) | [[nodiscard]] constexpr size_t count() const noexcept {
      method flush (line 669) | [[nodiscard]] constexpr result<void> flush() noexcept {
      method request_write_area (line 683) | constexpr result<std::span<char>> request_write_area(const size_t /*...
    type detail (line 701) | namespace detail {
      function Container (line 365) | Container& get_container(std::back_insert_iterator<Container> it) no...
      type get_value_type (line 376) | struct get_value_type {
      type get_value_type<std::back_insert_iterator<Container>> (line 381) | struct get_value_type<std::back_insert_iterator<Container>> {
      type get_value_type<std::ostreambuf_iterator<Char, Traits>> (line 387) | struct get_value_type<std::ostreambuf_iterator<Char, Traits>> {
      function copy_str (line 396) | constexpr auto copy_str(InputIt it, InputIt end, OutputIt out) -> Ou...
      class counting_buffer (line 709) | class counting_buffer final : public buffer {
        method counting_buffer (line 712) | constexpr counting_buffer() noexcept = default;
        method counting_buffer (line 713) | constexpr counting_buffer(const counting_buffer&) = delete;
        method counting_buffer (line 714) | constexpr counting_buffer(counting_buffer&&) noexcept = delete;
        method counting_buffer (line 715) | constexpr counting_buffer& operator=(const counting_buffer&) = del...
        method counting_buffer (line 716) | constexpr counting_buffer& operator=(counting_buffer&&) noexcept =...
        method count (line 723) | [[nodiscard]] constexpr size_t count() const noexcept {
        method request_write_area (line 728) | constexpr result<std::span<char>> request_write_area(const size_t ...

FILE: include/emio/detail/args.hpp
  type emio::detail (line 15) | namespace emio::detail {
    class validation_arg (line 21) | class validation_arg {
      method validation_arg (line 25) | explicit validation_arg(std::type_identity<T> /*unused*/) noexcept {
      method validation_arg (line 30) | validation_arg(const validation_arg&) = delete;
      method validation_arg (line 31) | validation_arg(validation_arg&&) = delete;
      method validation_arg (line 32) | validation_arg& operator=(const validation_arg&) = delete;
      method validation_arg (line 33) | validation_arg& operator=(validation_arg&&) = delete;
      method validate (line 37) | result<void> validate(reader& format_rdr) const noexcept {
      class concept_t (line 43) | class concept_t {
        method concept_t (line 45) | concept_t() = default;
        method concept_t (line 46) | concept_t(const concept_t&) = delete;
        method concept_t (line 47) | concept_t(concept_t&&) = delete;
        method concept_t (line 48) | concept_t& operator=(const concept_t&) = delete;
        method concept_t (line 49) | concept_t& operator=(concept_t&&) = delete;
      class model_t (line 58) | class model_t final : public concept_t {
        method model_t (line 60) | explicit model_t() noexcept = default;
        method model_t (line 61) | model_t(const model_t&) = delete;
        method model_t (line 62) | model_t(model_t&&) = delete;
        method model_t (line 63) | model_t& operator=(const model_t&) = delete;
        method model_t (line 64) | model_t& operator=(model_t&&) = delete;
        method validate (line 66) | result<void> validate(reader& format_rdr) const noexcept override {
    class arg (line 81) | class arg {
      method arg (line 85) | explicit arg(T& value) noexcept {
      method arg (line 90) | arg(const arg&) = delete;
      method arg (line 91) | arg(arg&&) = delete;
      method arg (line 92) | arg& operator=(const arg&) = delete;
      method arg (line 93) | arg& operator=(arg&&) = delete;
      method process_arg (line 96) | result<void> process_arg(Input& input, reader& format_rdr) const noe...
      class concept_t (line 102) | class concept_t {
        method concept_t (line 104) | concept_t() = default;
        method concept_t (line 105) | concept_t(const concept_t&) = delete;
        method concept_t (line 106) | concept_t(concept_t&&) = delete;
        method concept_t (line 107) | concept_t& operator=(const concept_t&) = delete;
        method concept_t (line 108) | concept_t& operator=(concept_t&&) = delete;
      class model_t (line 117) | class model_t final : public concept_t {
        method model_t (line 119) | explicit model_t(T value) noexcept : value_{value} {}
        method model_t (line 121) | model_t(const model_t&) = delete;
        method model_t (line 122) | model_t(model_t&&) = delete;
        method model_t (line 123) | model_t& operator=(const model_t&) = delete;
        method model_t (line 124) | model_t& operator=(model_t&&) = delete;
        method process_arg (line 126) | result<void> process_arg(Input& input, reader& format_rdr) const n...
    class args_span (line 141) | class args_span {
      method args_span (line 143) | args_span() = default;
      method args_span (line 144) | args_span(const args_span&) = delete;
      method args_span (line 145) | args_span(args_span&&) = delete;
      method args_span (line 146) | args_span& operator=(const args_span&) = delete;
      method args_span (line 147) | args_span& operator=(args_span&&) = delete;
      method get_args (line 150) | [[nodiscard]] std::span<const Arg> get_args() const noexcept {
      method args_span (line 155) | args_span(std::span<const Arg> args) : args_{args} {}
    class args_span_with_str (line 162) | class args_span_with_str : public args_span<Arg> {
      method args_span_with_str (line 164) | args_span_with_str() = default;
      method args_span_with_str (line 165) | args_span_with_str(const args_span_with_str&) = delete;
      method args_span_with_str (line 166) | args_span_with_str(args_span_with_str&&) = delete;
      method args_span_with_str (line 167) | args_span_with_str& operator=(const args_span_with_str&) = delete;
      method args_span_with_str (line 168) | args_span_with_str& operator=(args_span_with_str&&) = delete;
      method get_str (line 175) | [[nodiscard]] result<std::string_view> get_str() const noexcept {
      method is_plain_str (line 184) | [[nodiscard]] constexpr bool is_plain_str() const noexcept {
      method empty (line 192) | [[nodiscard]] constexpr bool empty() const noexcept {
      method args_span_with_str (line 198) | args_span_with_str(const validated_string_storage& str, std::span<co...
    class args_storage (line 206) | class args_storage : public args_span_with_str<Arg> {
      method args_storage (line 210) | args_storage(const validated_string_storage& str, Args&&... args) no...
      method args_storage (line 213) | args_storage(const args_storage&) = delete;
      method args_storage (line 214) | args_storage(args_storage&&) = delete;
      method args_storage (line 215) | args_storage& operator=(const args_storage&) = delete;
      method args_storage (line 216) | args_storage& operator=(args_storage&&) = delete;
    class validation_args_storage (line 224) | class validation_args_storage : public args_span<Arg> {
      method validation_args_storage (line 227) | validation_args_storage(Args&&... args) noexcept
      method validation_args_storage (line 230) | validation_args_storage(const validation_args_storage&) = delete;
      method validation_args_storage (line 231) | validation_args_storage(validation_args_storage&&) = delete;
      method validation_args_storage (line 232) | validation_args_storage& operator=(const validation_args_storage&) =...
      method validation_args_storage (line 233) | validation_args_storage& operator=(validation_args_storage&&) = delete;
    function make_validation_args (line 241) | validation_args_storage<T, sizeof...(Args)> make_validation_args() noe...

FILE: include/emio/detail/bignum.hpp
  type emio::detail (line 20) | namespace emio::detail {
    type carrying_add_result_t (line 22) | struct carrying_add_result_t {
    function carrying_add_result_t (line 30) | inline constexpr carrying_add_result_t carrying_add(uint32_t a, uint32...
    type borrowing_sub_result_t (line 38) | struct borrowing_sub_result_t {
    function borrowing_sub_result_t (line 46) | inline constexpr borrowing_sub_result_t borrowing_sub(uint32_t a, uint...
    type carrying_mul_result_t (line 54) | struct carrying_mul_result_t {
    function carrying_mul_result_t (line 62) | inline constexpr carrying_mul_result_t carrying_mul(uint32_t a, uint32...
    class bignum (line 70) | class bignum {
      method bignum (line 74) | static constexpr bignum from(size_t sz, const std::array<uint32_t, m...
      method bignum (line 81) | constexpr explicit bignum() noexcept = default;
      method bignum (line 86) | constexpr explicit bignum(T v) noexcept : base_{{v}} {}
      method bignum (line 91) | constexpr explicit bignum(T v) noexcept : base_{{static_cast<uint32_...
      method digits (line 98) | constexpr std::span<uint32_t> digits() noexcept {
      method get_bit (line 104) | [[nodiscard]] constexpr uint8_t get_bit(size_t i) const noexcept {
      method is_zero (line 112) | [[nodiscard]] constexpr bool is_zero() const noexcept {
      method bignum (line 120) | constexpr bignum& add_small(uint32_t other) noexcept {
      method bignum (line 124) | constexpr bignum& add_small_at(size_t index, uint32_t other) noexcept {
      method bignum (line 138) | constexpr bignum& add(const bignum& other) noexcept {
      method bignum (line 153) | constexpr bignum& sub_small(uint32_t other) noexcept {
      method bignum (line 169) | constexpr bignum& sub(const bignum& other) noexcept {
      method bignum (line 190) | constexpr bignum& mul_small(uint32_t other) noexcept {
      method bignum (line 194) | constexpr bignum& muladd_small(uint32_t other, uint32_t carry) noexc...
      method bignum (line 207) | [[nodiscard]] bignum mul(const bignum& other) const noexcept {
      method bignum (line 225) | constexpr bignum& mul_digits(std::span<const uint32_t> other) noexce...
      method bignum (line 245) | constexpr bignum& mul_pow5(size_t k) noexcept {
      method div_rem_small (line 265) | constexpr uint32_t div_rem_small(uint32_t other) noexcept {
      method bignum (line 277) | constexpr bignum& mul_pow2(size_t exp) noexcept {

FILE: include/emio/detail/bitset.hpp
  type emio::detail (line 14) | namespace emio::detail {
    class bitset (line 21) | class bitset {
      method all (line 32) | [[nodiscard]] constexpr bool all() const noexcept {
      method all_first (line 51) | [[nodiscard, gnu::noinline]] constexpr bool all_first(size_t n) cons...
      method size (line 80) | [[nodiscard]] constexpr size_t size() const noexcept {
      method set (line 88) | constexpr void set(size_t pos) noexcept {
      method word_t (line 98) | static constexpr word_t get_high_word_mask() noexcept {

FILE: include/emio/detail/conversion.hpp
  type emio::detail (line 19) | namespace emio::detail {
    function isalpha (line 21) | constexpr bool isalpha(char c) {
    function isdigit (line 25) | constexpr bool isdigit(char c) {
    function is_valid_number_base (line 29) | constexpr bool is_valid_number_base(const int base) noexcept {
    function char_to_digit (line 33) | constexpr std::optional<int> char_to_digit(const char c, const int bas...
    function digit_to_char (line 51) | constexpr char digit_to_char(const int digit, bool upper) noexcept {
    function count_digits_10 (line 65) | constexpr size_t count_digits_10(T number) noexcept {
    function count_digits (line 90) | constexpr size_t count_digits(T number) noexcept {
    function get_number_of_digits (line 114) | constexpr size_t get_number_of_digits(T number, int base) noexcept {
    function is_negative (line 138) | constexpr bool is_negative(T value) noexcept {
    function num_bits (line 147) | constexpr int num_bits() noexcept {
    function integer_upcast (line 162) | constexpr auto integer_upcast(T integer) noexcept {
    function to_absolute (line 167) | constexpr uint32_or_64<T> to_absolute(T number) noexcept {
    function to_unsigned (line 181) | constexpr std::make_unsigned_t<T> to_unsigned(T number) noexcept {
    function to_signed (line 186) | constexpr std::make_signed_t<T> to_signed(T number) noexcept {
    function copy2 (line 202) | inline constexpr void copy2(Char* dst, const char* src) noexcept {
    function unchecked_substr (line 275) | constexpr std::string_view unchecked_substr(const std::string_view& st...
    function equal_n (line 306) | [[nodiscard]] inline constexpr bool equal_n(const char* a, const char*...
    function sv (line 323) | inline consteval std::string_view sv(std::string_view sv) noexcept {
    function begin (line 339) | constexpr auto begin(T& obj) noexcept {
    function end (line 349) | constexpr auto end(T& obj) noexcept {

FILE: include/emio/detail/ct_vector.hpp
  type emio::detail (line 16) | namespace emio::detail {
    class ct_vector (line 24) | class ct_vector {
      method ct_vector (line 26) | constexpr ct_vector() noexcept {
      method ct_vector (line 32) | constexpr ct_vector(const ct_vector& other) : ct_vector() {
      method ct_vector (line 37) | constexpr ct_vector(ct_vector&& other) noexcept : ct_vector() {
      method ct_vector (line 53) | constexpr ct_vector& operator=(const ct_vector& other) {
      method ct_vector (line 62) | constexpr ct_vector& operator=(ct_vector&& other) noexcept {
      method reserve (line 94) | constexpr void reserve(size_t new_size) noexcept {
      method clear (line 118) | constexpr void clear() noexcept {
      method capacity (line 122) | [[nodiscard]] constexpr size_t capacity() const noexcept {
      method size (line 126) | [[nodiscard]] constexpr size_t size() const noexcept {
      method Char (line 130) | [[nodiscard]] constexpr Char* data() noexcept {
      method Char (line 134) | [[nodiscard]] constexpr const Char* data() const noexcept {
      method hold_external (line 139) | [[nodiscard]] constexpr bool hold_external() const noexcept {

FILE: include/emio/detail/format/args.hpp
  type emio::detail::format (line 12) | namespace emio::detail::format {
    type format_arg_trait (line 15) | struct format_arg_trait {
      method validate (line 18) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method process_arg (line 22) | static constexpr result<void> process_arg(writer& out, reader& forma...

FILE: include/emio/detail/format/decode.hpp
  type emio::detail::format (line 18) | namespace emio::detail::format {
    type finite_result_t (line 20) | struct finite_result_t {
    type category (line 28) | enum class category { zero, finite, infinity, nan }
    type decode_result_t (line 30) | struct decode_result_t {
    function decode_result_t (line 36) | inline constexpr decode_result_t decode(double value) noexcept {

FILE: include/emio/detail/format/dragon.hpp
  type emio::detail::format (line 25) | namespace emio::detail::format {
    function estimate_scaling_factor (line 27) | inline constexpr int16_t estimate_scaling_factor(uint64_t mant, int16_...
    function round_up (line 35) | inline constexpr std::optional<char> round_up(std::span<char> d) noexc...
    type format_fp_result_t (line 60) | struct format_fp_result_t {
    type format_exact_mode (line 65) | enum class format_exact_mode { significand_digits, decimal_point }
    function format_fp_result_t (line 67) | inline constexpr format_fp_result_t format_exact(const finite_result_t...
    function format_fp_result_t (line 207) | inline constexpr format_fp_result_t format_shortest(const finite_resul...

FILE: include/emio/detail/format/format_to.hpp
  type emio (line 16) | namespace emio {
    type detail::format (line 18) | namespace detail::format {
      type format_trait (line 20) | struct format_trait {
        method validate_string (line 22) | [[nodiscard]] static constexpr bool validate_string(std::string_vi...
      function vformat_to (line 39) | inline result<void> vformat_to(buffer& buf, const format_args& args)...
      function format_to (line 50) | constexpr result<void> format_to(buffer& buf, const format_string<Ar...
      type unified_type<T> (line 94) | struct unified_type<T> {
    class formatter<detail::format::format_args> (line 66) | class formatter<detail::format::format_args> {
      method validate (line 68) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 72) | static constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 76) | static result<void> format(writer& out, const detail::format::format...
    class formatter<T> (line 88) | class formatter<T> : public formatter<detail::format::format_args> {}
    type detail::format (line 90) | namespace detail::format {
      type format_trait (line 20) | struct format_trait {
        method validate_string (line 22) | [[nodiscard]] static constexpr bool validate_string(std::string_vi...
      function vformat_to (line 39) | inline result<void> vformat_to(buffer& buf, const format_args& args)...
      function format_to (line 50) | constexpr result<void> format_to(buffer& buf, const format_string<Ar...
      type unified_type<T> (line 94) | struct unified_type<T> {

FILE: include/emio/detail/format/formatter.hpp
  type emio (line 15) | namespace emio {
    class formatter (line 18) | class formatter
    type detail::format (line 20) | namespace detail::format {
      type alternate_form (line 22) | namespace alternate_form {
      function write_padding_left (line 38) | inline constexpr result<void> write_padding_left(writer& out, format...
      function write_padding_right (line 55) | inline constexpr result<void> write_padding_right(writer& out, forma...
      function write_padded (line 63) | constexpr result<void> write_padded(writer& out, format_specs& specs...
      function make_write_int_options (line 72) | inline constexpr result<std::pair<std::string_view, writer::write_in...
      function try_write_sign (line 110) | inline constexpr result<char> try_write_sign(writer& out, const form...
      function try_write_prefix (line 124) | inline constexpr result<std::string_view> try_write_prefix(writer& o...
      function write_arg (line 139) | constexpr result<void> write_arg(writer& out, format_specs& specs, c...
      function write_non_finite (line 181) | inline constexpr result<void> write_non_finite(writer& out, bool upp...
      type fp_format (line 191) | enum class fp_format : uint8_t {
      type fp_format_specs (line 198) | struct fp_format_specs {
      function fp_format_specs (line 205) | inline constexpr fp_format_specs parse_fp_format_specs(const format_...
      function write_decimal (line 262) | inline constexpr result<void> write_decimal(writer& out, format_spec...
      function format_fp_result_t (line 415) | inline constexpr format_fp_result_t format_decimal(buffer& buffer, c...
      function format_and_write_decimal (line 441) | inline constexpr result<void> format_and_write_decimal(writer& out, ...
      function write_arg (line 468) | constexpr result<void> write_arg(writer& out, format_specs& specs, c...
      function write_arg (line 472) | inline constexpr result<void> write_arg(writer& out, format_specs& s...
      function write_arg (line 489) | constexpr result<void> write_arg(writer& out, format_specs& specs, c...
      function write_arg (line 510) | constexpr result<void> write_arg(writer& out, format_specs& specs, A...
      function write_arg (line 522) | constexpr result<void> write_arg(writer& out, format_specs& specs, A...
      function validate_format_specs (line 542) | inline constexpr result<void> validate_format_specs(reader& format_r...
      function parse_format_specs (line 623) | inline constexpr result<void> parse_format_specs(reader& format_rdr,...
      function check_integral_specs (line 686) | inline constexpr result<void> check_integral_specs(const format_spec...
      function check_unsigned_specs (line 706) | inline constexpr result<void> check_unsigned_specs(const format_spec...
      function check_bool_specs (line 713) | inline constexpr result<void> check_bool_specs(const format_specs& s...
      function check_char_specs (line 723) | inline constexpr result<void> check_char_specs(const format_specs& s...
      function check_pointer_specs (line 733) | inline constexpr result<void> check_pointer_specs(const format_specs...
      function check_floating_point_specs (line 743) | inline constexpr result<void> check_floating_point_specs(const forma...
      function check_string_specs (line 764) | inline constexpr result<void> check_string_specs(const format_specs&...
      function validate_trait (line 805) | constexpr result<void> validate_trait(reader& format_rdr) {
      type unified_type (line 836) | struct unified_type
      type unified_type (line 839) | struct unified_type {
      type unified_type<T> (line 845) | struct unified_type<T> {
      type unified_type<T> (line 851) | struct unified_type<T> {
      type unified_type<T> (line 857) | struct unified_type<T> {
      type unified_type<T> (line 863) | struct unified_type<T> {
      type unified_type<T> (line 869) | struct unified_type<T> {

FILE: include/emio/detail/format/parser.hpp
  type emio::detail::format (line 12) | namespace emio::detail::format {
    class format_parser (line 14) | class format_parser final : public parser<format_parser, input_validat...
      method format_parser (line 16) | constexpr explicit format_parser(writer& out, reader& format_rdr) no...
      method format_parser (line 19) | format_parser(const format_parser&) = delete;
      method format_parser (line 20) | format_parser(format_parser&&) = delete;
      method format_parser (line 21) | format_parser& operator=(const format_parser&) = delete;
      method format_parser (line 22) | format_parser& operator=(format_parser&&) = delete;
      method process (line 25) | constexpr result<void> process(const std::string_view& str) noexcept...
      method process_arg (line 29) | result<void> process_arg(const format_arg& arg) noexcept {
      method process_arg (line 34) | constexpr result<void> process_arg(const Arg& arg) noexcept {
    class format_specs_checker (line 52) | class format_specs_checker final : public parser<format_specs_checker,...
      method format_specs_checker (line 56) | format_specs_checker(const format_specs_checker& other) = delete;
      method format_specs_checker (line 57) | format_specs_checker(format_specs_checker&& other) = delete;
      method format_specs_checker (line 58) | format_specs_checker& operator=(const format_specs_checker& other) =...
      method format_specs_checker (line 59) | format_specs_checker& operator=(format_specs_checker&& other) = delete;
      method process_arg (line 62) | result<void> process_arg(const format_validation_arg& arg) noexcept {
      method process_arg (line 67) | constexpr result<void> process_arg(std::type_identity<Arg> /*unused*...

FILE: include/emio/detail/format/ranges.hpp
  type emio::detail::format (line 17) | namespace emio::detail::format {
    type is_span (line 52) | struct is_span : std::false_type {}
    type is_span<std::span<T, N>> (line 55) | struct is_span<std::span<T, N>> : std::true_type {}
    type ranges_specs (line 64) | struct ranges_specs {
    function maybe_set_debug_format (line 72) | constexpr void maybe_set_debug_format(Formatter& f, bool set) noexcept {
    function maybe_set_debug_format (line 77) | constexpr void maybe_set_debug_format(Formatter& /*unused*/, ...) noex...
    function has_tuple_element_unpack (line 91) | constexpr auto has_tuple_element_unpack(std::index_sequence<Ns...> /*u...
    function is_formattable_unpack (line 102) | constexpr auto is_formattable_unpack(std::index_sequence<Ns...> /*unus...

FILE: include/emio/detail/format/specs.hpp
  type emio::detail::format (line 11) | namespace emio::detail::format {
    type alignment (line 33) | enum class alignment : uint8_t { none, left, center, right }
    type format_specs (line 35) | struct format_specs {

FILE: include/emio/detail/misc.hpp
  type emio::detail (line 11) | namespace emio::detail {
    type always_false (line 14) | struct always_false : std::false_type {}
    type overload (line 20) | struct overload : Ts... {

FILE: include/emio/detail/parser.hpp
  type emio::detail (line 18) | namespace emio::detail {
    type input_validation (line 23) | enum class input_validation { enabled, disabled }
    class parser_base (line 28) | class parser_base {
      method parser_base (line 30) | constexpr explicit parser_base(reader& format_rdr) noexcept : format...
      method parser_base (line 32) | parser_base(const parser_base&) = delete;
      method parser_base (line 33) | parser_base(parser_base&&) = delete;
      method parser_base (line 34) | parser_base& operator=(const parser_base&) = delete;
      method parser_base (line 35) | parser_base& operator=(parser_base&&) = delete;
      method parse (line 39) | constexpr result<void> parse(uint8_t& arg_nbr) noexcept {
      method parse_replacement_field (line 67) | constexpr result<void> parse_replacement_field(uint8_t& arg_nbr) noe...
      method parse_field_name (line 82) | constexpr result<void> parse_field_name(uint8_t& arg_nbr) noexcept {
    class parser_base<input_validation::disabled> (line 106) | class parser_base<input_validation::disabled> {
      method parser_base (line 108) | constexpr explicit parser_base(reader& format_rdr) noexcept : format...
      method parser_base (line 110) | parser_base(const parser_base& other) = delete;
      method parser_base (line 111) | parser_base(parser_base&& other) = delete;
      method parser_base (line 112) | parser_base& operator=(const parser_base& other) = delete;
      method parser_base (line 113) | parser_base& operator=(parser_base&& other) = delete;
      method parse (line 117) | constexpr result<void> parse(uint8_t& arg_nbr) noexcept {
      method parse_replacement_field (line 156) | constexpr result<void> parse_replacement_field(uint8_t& arg_nbr) noe...
      method parse_field_name (line 166) | constexpr void parse_field_name(uint8_t& arg_nbr) noexcept {
    type related_format_args (line 184) | struct related_format_args {
    class parser (line 192) | class parser : public parser_base<Validation> {
      method parser (line 196) | parser(const parser&) = delete;
      method parser (line 197) | parser(parser&&) = delete;
      method parser (line 198) | parser& operator=(const parser&) = delete;
      method parser (line 199) | parser& operator=(parser&&) = delete;
      method apply (line 203) | result<void> apply(uint8_t arg_nbr, const related_format_args<Arg>& ...
      method apply (line 208) | constexpr result<void> apply(uint8_t /*arg_pos*/) noexcept {
      method apply (line 213) | constexpr result<void> apply(uint8_t arg_pos, Arg& arg, Args&... arg...
    function validate (line 226) | constexpr bool validate(std::string_view str, const size_t arg_cnt, co...
    function parse (line 251) | constexpr result<void> parse(std::string_view str, T& input, Args&&......

FILE: include/emio/detail/predef.hpp
  type emio::detail (line 9) | namespace emio::detail {

FILE: include/emio/detail/scan/args.hpp
  type emio::detail::scan (line 12) | namespace emio::detail::scan {
    type scan_arg_trait (line 15) | struct scan_arg_trait {
      method validate (line 18) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method process_arg (line 35) | static constexpr result<void> process_arg(reader& in, reader& format...

FILE: include/emio/detail/scan/parser.hpp
  type emio::detail::scan (line 12) | namespace emio::detail::scan {
    class scan_parser (line 14) | class scan_parser final : public parser<scan_parser, input_validation:...
      method scan_parser (line 16) | constexpr explicit scan_parser(reader& in, reader& format_rdr) noexcept
      method scan_parser (line 19) | scan_parser(const scan_parser&) = delete;
      method scan_parser (line 20) | scan_parser(scan_parser&&) = delete;
      method scan_parser (line 21) | scan_parser& operator=(const scan_parser&) = delete;
      method scan_parser (line 22) | scan_parser& operator=(scan_parser&&) = delete;
      method process (line 25) | constexpr result<void> process(const std::string_view& str) noexcept...
      method process_arg (line 29) | result<void> process_arg(const scan_arg& arg) noexcept {
      method process_arg (line 34) | constexpr result<void> process_arg(Arg& arg) noexcept {
    class scan_specs_checker (line 52) | class scan_specs_checker final : public parser<scan_specs_checker, inp...
      method scan_specs_checker (line 56) | scan_specs_checker(const scan_specs_checker& other) = delete;
      method scan_specs_checker (line 57) | scan_specs_checker(scan_specs_checker&& other) = delete;
      method scan_specs_checker (line 58) | scan_specs_checker& operator=(const scan_specs_checker& other) = del...
      method scan_specs_checker (line 59) | scan_specs_checker& operator=(scan_specs_checker&& other) = delete;
      method process_arg (line 62) | result<void> process_arg(const scan_validation_arg& arg) noexcept {
      method process_arg (line 67) | constexpr result<void> process_arg(std::type_identity<Arg> /*unused*...

FILE: include/emio/detail/scan/scan_from.hpp
  type emio::detail::scan (line 15) | namespace emio::detail::scan {
    type scan_trait (line 17) | struct scan_trait {
      method validate_string (line 19) | [[nodiscard]] static constexpr bool validate_string(std::string_view...
    function vscan_from (line 35) | inline result<void> vscan_from(reader& in, const scan_args& args) noex...
    function scan_from (line 44) | constexpr result<void> scan_from(reader& in, const format_string<Args....

FILE: include/emio/detail/scan/scanner.hpp
  type emio (line 12) | namespace emio {
    class scanner (line 15) | class scanner
    type detail::scan (line 17) | namespace detail::scan {
      function disallow_sign (line 23) | inline constexpr result<void> disallow_sign(reader& in) noexcept {
      function determine_base (line 31) | inline constexpr result<int> determine_base(reader in) noexcept {
      function get_base (line 52) | inline constexpr int get_base(char type) noexcept {
      function parse_alternate_form (line 69) | inline constexpr result<void> parse_alternate_form(reader& in, int b...
      function read_arg (line 93) | constexpr result<void> read_arg(reader& original_in, const format_sp...
      function read_arg (line 138) | constexpr result<void> read_arg(reader& in, const format_specs& /*un...
      function read_string_complex (line 143) | inline constexpr result<void> read_string_complex(reader& in, const ...
      function read_string (line 203) | inline constexpr result<void> read_string(reader& in, format_specs& ...
      function validate_format_specs (line 243) | inline constexpr result<void> validate_format_specs(reader& format_r...
      function parse_format_specs (line 272) | inline constexpr result<void> parse_format_specs(reader& format_rdr,...
      function check_char_specs (line 294) | inline constexpr result<void> check_char_specs(const format_specs& s...
      function check_integral_specs (line 301) | inline constexpr result<void> check_integral_specs(const format_spec...
      function check_string_specs (line 314) | inline constexpr result<void> check_string_specs(const format_specs&...

FILE: include/emio/detail/scan/specs.hpp
  type emio::detail::scan (line 13) | namespace emio::detail::scan {
    type format_specs (line 18) | struct format_specs {

FILE: include/emio/detail/utf.hpp
  type emio::detail (line 18) | namespace emio::detail {
    function needs_escape (line 20) | inline constexpr bool needs_escape(uint32_t cp) noexcept {
    function count_size_when_escaped (line 24) | inline constexpr size_t count_size_when_escaped(std::string_view sv) n...
    class write_escaped_helper (line 41) | class write_escaped_helper {
      method write_escaped_helper (line 43) | constexpr write_escaped_helper(std::string_view sv) noexcept
      method write_escaped (line 46) | [[nodiscard]] constexpr size_t write_escaped(std::span<char> area) n...
    function write_str_escaped (line 126) | inline constexpr result<void> write_str_escaped(buffer& buf, std::stri...

FILE: include/emio/detail/validated_string.hpp
  type emio (line 15) | namespace emio {
    type detail (line 17) | namespace detail {
      class runtime_string (line 22) | class runtime_string {
        method runtime_string (line 27) | constexpr runtime_string() = default;
        method runtime_string (line 30) | constexpr runtime_string(std::nullptr_t) = delete;
        method runtime_string (line 31) | constexpr runtime_string(int) = delete;
        method runtime_string (line 34) | constexpr runtime_string(std::string&&) = delete;
        method runtime_string (line 43) | constexpr explicit runtime_string(const S& str) : str_{str} {}
        method get (line 49) | [[nodiscard]] constexpr std::string_view get() const noexcept {
      class valid_string (line 58) | class valid_string
        method from (line 120) | static constexpr result<valid_string<Trait, Args...>> from(const S...
        method valid_string (line 135) | consteval valid_string(const S& s) noexcept : validated_string<Tra...
        method valid_string (line 140) | constexpr explicit valid_string(const validated_string_storage& st...
      class validated_string (line 66) | class validated_string : public validated_string_storage {
        method validated_string (line 75) | consteval validated_string(const S& s) noexcept
        method validated_string (line 87) | constexpr validated_string(const runtime_string& s) noexcept
        method as_valid (line 95) | constexpr result<valid_string<Trait, Args...>> as_valid() const no...
        method validated_string (line 103) | constexpr explicit validated_string(const validated_string_storage...
      class valid_string (line 111) | class valid_string : public validated_string<Trait, Args...> {
        method from (line 120) | static constexpr result<valid_string<Trait, Args...>> from(const S...
        method valid_string (line 135) | consteval valid_string(const S& s) noexcept : validated_string<Tra...
        method valid_string (line 140) | constexpr explicit valid_string(const validated_string_storage& st...
    function runtime_string (line 154) | inline constexpr runtime_string runtime(const std::string_view& s) noe...

FILE: include/emio/detail/validated_string_storage.hpp
  type emio::detail (line 14) | namespace emio::detail {
    function check_if_plain_string (line 16) | inline constexpr bool check_if_plain_string(const std::string_view& s)...
    class validated_string_storage (line 25) | class validated_string_storage {
      method validated_string_storage (line 28) | static constexpr validated_string_storage from(const std::string_vie...
      method validated_string_storage (line 40) | constexpr validated_string_storage() noexcept = default;
      method is_plain_str (line 46) | [[nodiscard]] constexpr bool is_plain_str() const noexcept {
      method empty (line 54) | [[nodiscard]] constexpr bool empty() const noexcept {
      method get (line 62) | constexpr result<std::string_view> get() const noexcept {
      method validated_string_storage (line 68) | constexpr validated_string_storage(const std::pair<bool, result<std:...

FILE: include/emio/format.hpp
  type emio (line 14) | namespace emio {
    function make_format_args (line 42) | [[nodiscard]] detail::args_storage<detail::format::format_arg, sizeof....
    function vformatted_size (line 53) | inline result<size_t> vformatted_size(const format_args& args) noexcept {
    function formatted_size (line 68) | [[nodiscard]] constexpr size_t formatted_size(const valid_format_strin...
    function formatted_size (line 87) | [[nodiscard]] constexpr result<size_t> formatted_size(const valid_form...
    function formatted_size (line 104) | constexpr result<size_t> formatted_size(const T& format_str, const Arg...
    function vformat_to (line 117) | inline result<void> vformat_to(buffer& buf, const format_args& args) n...
    function vformat_to (line 128) | inline result<void> vformat_to(writer& out, const format_args& args) n...
    function vformat_to (line 142) | constexpr result<OutputIt> vformat_to(OutputIt out, const format_args&...
    function format_to (line 156) | constexpr result<void> format_to(buffer& buf, const emio::format_strin...
    function format_to (line 174) | constexpr result<void> format_to(writer& out, const emio::format_strin...
    function format_to (line 193) | constexpr result<OutputIt> format_to(OutputIt out, const emio::format_...
    function vformat (line 211) | inline result<std::string> vformat(const format_args& args) noexcept {
    function format (line 228) | [[nodiscard]] std::string format(const emio::valid_format_string<Args....
    function format (line 241) | [[nodiscard]] result<std::string> format(const emio::valid_format_stri...
    function format (line 254) | result<std::string> format(T format_str, const Args&... args) noexcept {
    type format_to_n_result (line 264) | struct format_to_n_result {
    function vformat_to_n (line 279) | result<format_to_n_result<OutputIt>> vformat_to_n(OutputIt out, std::i...
    function vformat_to_n (line 299) | result<size_t> vformat_to_n(buffer& buf, size_t n, const format_args& ...
    function format_to_n (line 317) | constexpr result<format_to_n_result<OutputIt>> format_to_n(OutputIt ou...
    function format_to_n (line 343) | constexpr result<size_t> format_to_n(buffer& buf, size_t n, const emio...
    function vprint (line 361) | inline result<void> vprint(std::FILE* file, const format_args& args) n...
    function print (line 379) | void print(const emio::valid_format_string<Args...>& format_str,
    function print (line 392) | result<void> print(const emio::valid_format_string<Args...>& format_st...
    function print (line 404) | result<void> print(const T& format_str, const Args&... args) noexcept {
    function print (line 416) | result<void> print(std::FILE* file, const emio::format_string<Args...>...
    function vprintln (line 427) | inline result<void> vprintln(std::FILE* file, const format_args& args)...
    function println (line 447) | void println(const emio::valid_format_string<Args...>& format_str,
    function println (line 461) | result<void> println(const emio::valid_format_string<Args...>& format_...
    function println (line 474) | result<void> println(const T& format_str, const Args&... args) noexcept {
    function println (line 486) | result<void> println(std::FILE* file, const emio::format_string<Args.....

FILE: include/emio/formatter.hpp
  type emio (line 13) | namespace emio {
    class formatter (line 35) | class formatter {
      method formatter (line 38) | formatter() = delete;
      method validate (line 46) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 55) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 65) | constexpr result<void> format(writer& out, const T& arg) const noexc...
    class formatter<T> (line 91) | class formatter<T> {
      method validate (line 93) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 117) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 121) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method set_debug_format (line 131) | constexpr void set_debug_format(bool enabled) noexcept
      method set_width (line 146) | constexpr void set_width(int32_t width) noexcept {
      method set_precision (line 155) | constexpr void set_precision(int32_t precision) noexcept {
      method format (line 179) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method format (line 203) | constexpr result<void> format(writer& out, const T& arg) const noexc...
    class formatter<T> (line 169) | class formatter<T> : public formatter<detail::format::unified_type_t<T...
      method validate (line 93) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 117) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 121) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method set_debug_format (line 131) | constexpr void set_debug_format(bool enabled) noexcept
      method set_width (line 146) | constexpr void set_width(int32_t width) noexcept {
      method set_precision (line 155) | constexpr void set_precision(int32_t precision) noexcept {
      method format (line 179) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method format (line 203) | constexpr result<void> format(writer& out, const T& arg) const noexc...
    class formatter<T> (line 177) | class formatter<T> : public formatter<std::underlying_type_t<T>> {
      method validate (line 93) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 117) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 121) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method set_debug_format (line 131) | constexpr void set_debug_format(bool enabled) noexcept
      method set_width (line 146) | constexpr void set_width(int32_t width) noexcept {
      method set_precision (line 155) | constexpr void set_precision(int32_t precision) noexcept {
      method format (line 179) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method format (line 203) | constexpr result<void> format(writer& out, const T& arg) const noexc...
    class formatter<std::byte> (line 188) | class formatter<std::byte> : public formatter<uint8_t> {
      method format (line 190) | constexpr result<void> format(writer& out, const std::byte& arg) con...
    class formatter<T> (line 201) | class formatter<T> : public formatter<detail::format::format_as_return...
      method validate (line 93) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 117) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 121) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method set_debug_format (line 131) | constexpr void set_debug_format(bool enabled) noexcept
      method set_width (line 146) | constexpr void set_width(int32_t width) noexcept {
      method set_precision (line 155) | constexpr void set_precision(int32_t precision) noexcept {
      method format (line 179) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method format (line 203) | constexpr result<void> format(writer& out, const T& arg) const noexc...
    type detail (line 208) | namespace detail {
      type format_spec_with_value (line 211) | struct format_spec_with_value
      type format_spec_with_value (line 247) | struct format_spec_with_value {
    type format_spec (line 218) | struct format_spec {
    type detail (line 241) | namespace detail {
      type format_spec_with_value (line 211) | struct format_spec_with_value
      type format_spec_with_value (line 247) | struct format_spec_with_value {
    class formatter<detail::format_spec_with_value<T>> (line 264) | class formatter<detail::format_spec_with_value<T>> {
      method validate (line 266) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 270) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 274) | constexpr result<void> format(writer& out, const detail::format_spec...
      method F (line 285) | static constexpr F& get_core_formatter(F& formatter) noexcept {
      method overwrite_spec (line 295) | constexpr void overwrite_spec(const format_spec& spec) noexcept {
    function ptr (line 316) | constexpr auto ptr(T p) noexcept {

FILE: include/emio/iterator.hpp
  type emio (line 11) | namespace emio {
    class truncating_iterator_base (line 18) | class truncating_iterator_base {
      method truncating_iterator_base (line 29) | constexpr truncating_iterator_base() = default;
      method truncating_iterator_base (line 36) | constexpr truncating_iterator_base(OutputIt out, size_t limit)
      method OutputIt (line 43) | constexpr OutputIt out() const {
      method count (line 51) | [[nodiscard]] constexpr std::iter_difference_t<OutputIt> count() con...
    class truncating_iterator (line 67) | class truncating_iterator
    class truncating_iterator<OutputIt> (line 79) | class truncating_iterator<OutputIt> : public truncating_iterator_base<...
      method truncating_iterator (line 84) | constexpr truncating_iterator& operator=(T val) {
      method truncating_iterator (line 92) | constexpr truncating_iterator& operator++() {
      method truncating_iterator (line 95) | constexpr truncating_iterator& operator++(int) {
      method truncating_iterator (line 98) | constexpr truncating_iterator& operator*() {
      method truncating_iterator (line 115) | constexpr truncating_iterator& operator++() {
      method truncating_iterator (line 123) | constexpr truncating_iterator operator++(int) {
      method value_type (line 129) | constexpr value_type& operator*() const {
    class truncating_iterator<OutputIt> (line 109) | class truncating_iterator<OutputIt> : public truncating_iterator_base<...
      method truncating_iterator (line 84) | constexpr truncating_iterator& operator=(T val) {
      method truncating_iterator (line 92) | constexpr truncating_iterator& operator++() {
      method truncating_iterator (line 95) | constexpr truncating_iterator& operator++(int) {
      method truncating_iterator (line 98) | constexpr truncating_iterator& operator*() {
      method truncating_iterator (line 115) | constexpr truncating_iterator& operator++() {
      method truncating_iterator (line 123) | constexpr truncating_iterator operator++(int) {
      method value_type (line 129) | constexpr value_type& operator*() const {
    type detail (line 140) | namespace detail {
      type get_value_type (line 143) | struct get_value_type
      type get_value_type<truncating_iterator<Iterator>> (line 146) | struct get_value_type<truncating_iterator<Iterator>> : get_value_typ...

FILE: include/emio/ranges.hpp
  type emio (line 14) | namespace emio {
    class formatter<T> (line 22) | class formatter<T> {
      method validate (line 24) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method formatter (line 39) | constexpr formatter() noexcept
      method formatter (line 43) | constexpr formatter() noexcept
      method formatter (line 50) | constexpr formatter() noexcept
      method set_separator (line 54) | constexpr void set_separator(std::string_view separator) noexcept {
      method set_brackets (line 58) | constexpr void set_brackets(std::string_view opening_bracket, std::s...
      method parse (line 63) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 78) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method formatter (line 120) | constexpr formatter() : specs_{detail::sv("("), detail::sv(")"), det...
      method set_separator (line 122) | constexpr void set_separator(std::string_view separator) noexcept {
      method set_brackets (line 126) | constexpr void set_brackets(std::string_view opening_bracket, std::s...
      method validate (line 131) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 146) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 162) | constexpr result<void> format(writer& out, const T& args) const noex...
      method validate_for_each (line 171) | static constexpr result<void> validate_for_each(std::index_sequence<...
      method validate_for_each (line 196) | static constexpr result<void> validate_for_each(std::index_sequence<...
      method parse_for_each (line 201) | constexpr result<void> parse_for_each(std::index_sequence<Ns...> /*u...
      method parse_for_each (line 221) | constexpr result<void> parse_for_each(std::index_sequence<> /*unused...
      method format_for_each (line 231) | constexpr result<void> format_for_each(std::index_sequence<N, Ns...>...
      method format_for_each (line 252) | constexpr result<void> format_for_each(std::index_sequence<> /*unuse...
    class formatter<T> (line 110) | class formatter<T> : public formatter<std::span<const detail::format::...
      method validate (line 24) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method formatter (line 39) | constexpr formatter() noexcept
      method formatter (line 43) | constexpr formatter() noexcept
      method formatter (line 50) | constexpr formatter() noexcept
      method set_separator (line 54) | constexpr void set_separator(std::string_view separator) noexcept {
      method set_brackets (line 58) | constexpr void set_brackets(std::string_view opening_bracket, std::s...
      method parse (line 63) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 78) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method formatter (line 120) | constexpr formatter() : specs_{detail::sv("("), detail::sv(")"), det...
      method set_separator (line 122) | constexpr void set_separator(std::string_view separator) noexcept {
      method set_brackets (line 126) | constexpr void set_brackets(std::string_view opening_bracket, std::s...
      method validate (line 131) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 146) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 162) | constexpr result<void> format(writer& out, const T& args) const noex...
      method validate_for_each (line 171) | static constexpr result<void> validate_for_each(std::index_sequence<...
      method validate_for_each (line 196) | static constexpr result<void> validate_for_each(std::index_sequence<...
      method parse_for_each (line 201) | constexpr result<void> parse_for_each(std::index_sequence<Ns...> /*u...
      method parse_for_each (line 221) | constexpr result<void> parse_for_each(std::index_sequence<> /*unused...
      method format_for_each (line 231) | constexpr result<void> format_for_each(std::index_sequence<N, Ns...>...
      method format_for_each (line 252) | constexpr result<void> format_for_each(std::index_sequence<> /*unuse...
    class formatter<T> (line 118) | class formatter<T> {
      method validate (line 24) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method formatter (line 39) | constexpr formatter() noexcept
      method formatter (line 43) | constexpr formatter() noexcept
      method formatter (line 50) | constexpr formatter() noexcept
      method set_separator (line 54) | constexpr void set_separator(std::string_view separator) noexcept {
      method set_brackets (line 58) | constexpr void set_brackets(std::string_view opening_bracket, std::s...
      method parse (line 63) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 78) | constexpr result<void> format(writer& out, const T& arg) const noexc...
      method formatter (line 120) | constexpr formatter() : specs_{detail::sv("("), detail::sv(")"), det...
      method set_separator (line 122) | constexpr void set_separator(std::string_view separator) noexcept {
      method set_brackets (line 126) | constexpr void set_brackets(std::string_view opening_bracket, std::s...
      method validate (line 131) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 146) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 162) | constexpr result<void> format(writer& out, const T& args) const noex...
      method validate_for_each (line 171) | static constexpr result<void> validate_for_each(std::index_sequence<...
      method validate_for_each (line 196) | static constexpr result<void> validate_for_each(std::index_sequence<...
      method parse_for_each (line 201) | constexpr result<void> parse_for_each(std::index_sequence<Ns...> /*u...
      method parse_for_each (line 221) | constexpr result<void> parse_for_each(std::index_sequence<> /*unused...
      method format_for_each (line 231) | constexpr result<void> format_for_each(std::index_sequence<N, Ns...>...
      method format_for_each (line 252) | constexpr result<void> format_for_each(std::index_sequence<> /*unuse...

FILE: include/emio/reader.hpp
  type emio (line 17) | namespace emio {
    class reader (line 20) | class reader
      method reader (line 50) | constexpr reader() = default;
      method reader (line 53) | constexpr reader(std::nullptr_t) = delete;
      method reader (line 54) | constexpr reader(int) = delete;
      method reader (line 56) | constexpr reader(std::string&&) = delete;
      method reader (line 66) | constexpr explicit reader(Arg&& input) noexcept : reader{std::string...
      method reader (line 72) | constexpr explicit reader(const std::string_view& sv) noexcept
      method pos (line 79) | [[nodiscard]] constexpr size_t pos() const noexcept {
      method eof (line 87) | [[nodiscard]] constexpr bool eof() const noexcept {
      method cnt_remaining (line 95) | [[nodiscard]] constexpr size_t cnt_remaining() const noexcept {
      method view_remaining (line 103) | [[nodiscard]] constexpr std::string_view view_remaining() const noex...
      method read_remaining (line 111) | [[nodiscard]] constexpr std::string_view read_remaining() noexcept {
      method pop (line 122) | constexpr void pop(const size_t cnt = 1) noexcept {
      method unpop (line 135) | constexpr void unpop(const size_t cnt = 1) noexcept {
      method subreader (line 150) | constexpr result<reader> subreader(const size_t pos, const size_t le...
      method peek (line 163) | constexpr result<char> peek() const noexcept {
      method read_char (line 174) | constexpr result<char> read_char() noexcept {
      method read_n_chars (line 186) | constexpr result<std::string_view> read_n_chars(const size_t n) noex...
      method parse_int (line 204) | constexpr result<T> parse_int(const int base = 10) noexcept {
      type read_until_options (line 231) | struct read_until_options {
      method read_until_char (line 244) | constexpr result<std::string_view> read_until_char(
      method read_until_str (line 256) | constexpr result<std::string_view> read_until_str(const std::string_...
      method read_until_any_of (line 267) | constexpr result<std::string_view> read_until_any_of(
      method read_until_none_of (line 279) | constexpr result<std::string_view> read_until_none_of(
      method read_until (line 293) | constexpr result<std::string_view>
      method read_if_match_char (line 304) | constexpr result<char> read_if_match_char(const char c) noexcept {
      method read_if_match_str (line 320) | constexpr result<std::string_view> read_if_match_str(const std::stri...
      method read_until_options (line 339) | [[nodiscard]] static constexpr read_until_options default_read_until...
      method parse_sign_and_int (line 344) | constexpr result<T> parse_sign_and_int(const int base) noexcept {
      method read_until_pos (line 349) | constexpr result<std::string_view> read_until_pos(size_t pos, const ...
      method read_until_match (line 358) | constexpr result<std::string_view> read_until_match(const char* matc...
    type detail (line 22) | namespace detail {
      function parse_sign (line 396) | inline constexpr result<bool> parse_sign(reader& in) noexcept {
      function parse_int (line 409) | constexpr result<T> parse_int(reader& in, const int base, const bool...
    class reader (line 40) | class reader {
      method reader (line 50) | constexpr reader() = default;
      method reader (line 53) | constexpr reader(std::nullptr_t) = delete;
      method reader (line 54) | constexpr reader(int) = delete;
      method reader (line 56) | constexpr reader(std::string&&) = delete;
      method reader (line 66) | constexpr explicit reader(Arg&& input) noexcept : reader{std::string...
      method reader (line 72) | constexpr explicit reader(const std::string_view& sv) noexcept
      method pos (line 79) | [[nodiscard]] constexpr size_t pos() const noexcept {
      method eof (line 87) | [[nodiscard]] constexpr bool eof() const noexcept {
      method cnt_remaining (line 95) | [[nodiscard]] constexpr size_t cnt_remaining() const noexcept {
      method view_remaining (line 103) | [[nodiscard]] constexpr std::string_view view_remaining() const noex...
      method read_remaining (line 111) | [[nodiscard]] constexpr std::string_view read_remaining() noexcept {
      method pop (line 122) | constexpr void pop(const size_t cnt = 1) noexcept {
      method unpop (line 135) | constexpr void unpop(const size_t cnt = 1) noexcept {
      method subreader (line 150) | constexpr result<reader> subreader(const size_t pos, const size_t le...
      method peek (line 163) | constexpr result<char> peek() const noexcept {
      method read_char (line 174) | constexpr result<char> read_char() noexcept {
      method read_n_chars (line 186) | constexpr result<std::string_view> read_n_chars(const size_t n) noex...
      method parse_int (line 204) | constexpr result<T> parse_int(const int base = 10) noexcept {
      type read_until_options (line 231) | struct read_until_options {
      method read_until_char (line 244) | constexpr result<std::string_view> read_until_char(
      method read_until_str (line 256) | constexpr result<std::string_view> read_until_str(const std::string_...
      method read_until_any_of (line 267) | constexpr result<std::string_view> read_until_any_of(
      method read_until_none_of (line 279) | constexpr result<std::string_view> read_until_none_of(
      method read_until (line 293) | constexpr result<std::string_view>
      method read_if_match_char (line 304) | constexpr result<char> read_if_match_char(const char c) noexcept {
      method read_if_match_str (line 320) | constexpr result<std::string_view> read_if_match_str(const std::stri...
      method read_until_options (line 339) | [[nodiscard]] static constexpr read_until_options default_read_until...
      method parse_sign_and_int (line 344) | constexpr result<T> parse_sign_and_int(const int base) noexcept {
      method read_until_pos (line 349) | constexpr result<std::string_view> read_until_pos(size_t pos, const ...
      method read_until_match (line 358) | constexpr result<std::string_view> read_until_match(const char* matc...
    type detail (line 386) | namespace detail {
      function parse_sign (line 396) | inline constexpr result<bool> parse_sign(reader& in) noexcept {
      function parse_int (line 409) | constexpr result<T> parse_int(reader& in, const int base, const bool...

FILE: include/emio/result.hpp
  type emio (line 36) | namespace emio {
    type err (line 41) | enum class err {
    function to_string (line 55) | constexpr std::string_view to_string(err error) noexcept {
    class bad_result_access (line 90) | class bad_result_access : public std::logic_error {
      method bad_result_access (line 96) | explicit bad_result_access(const std::string_view& msg) : logic_erro...
      method bad_result_access (line 105) | explicit bad_result_access(const std::string_view& msg) : msg_{msg} {}
    class bad_result_access (line 99) | class bad_result_access : public std::exception {
      method bad_result_access (line 96) | explicit bad_result_access(const std::string_view& msg) : logic_erro...
      method bad_result_access (line 105) | explicit bad_result_access(const std::string_view& msg) : msg_{msg} {}
    type detail (line 116) | namespace detail {
      function throw_bad_result_access_or_terminate (line 125) | [[noreturn]] inline void throw_bad_result_access_or_terminate(const ...
      type is_result (line 505) | struct is_result : std::false_type {}
      type is_result<result<T>> (line 508) | struct is_result<result<T>> : std::true_type {}
    class result (line 144) | class [[nodiscard]] result
    class result<Value> (line 152) | class [[nodiscard]] result<Value> {
      method result (line 157) | constexpr result() = delete;
      method result (line 166) | constexpr explicit(!std::is_convertible_v<U, Value>) result(U&& valu...
      method result (line 172) | constexpr result(err error) : error_{error} {
      method has_value (line 188) | [[nodiscard]] constexpr bool has_value() const noexcept {
      method has_error (line 196) | [[nodiscard]] constexpr bool has_error() const noexcept {
      method Value (line 225) | [[nodiscard]] constexpr Value& operator*() & noexcept {
      method Value (line 235) | [[nodiscard]] constexpr const Value& operator*() const& noexcept {
      method Value (line 245) | [[nodiscard]] constexpr Value&& operator*() && noexcept {
      method Value (line 255) | [[nodiscard]] constexpr const Value&& operator*() const&& noexcept {
      method Value (line 265) | [[nodiscard]] constexpr Value& assume_value() & noexcept {
      method Value (line 275) | [[nodiscard]] constexpr const Value& assume_value() const& noexcept {
      method Value (line 285) | [[nodiscard]] constexpr Value&& assume_value() && noexcept {
      method Value (line 295) | [[nodiscard]] constexpr const Value&& assume_value() const&& noexcept {
      method Value (line 304) | constexpr Value& value() & noexcept(detail::exceptions_disabled) {
      method Value (line 315) | [[nodiscard]] constexpr const Value& value() const& noexcept(detail:...
      method Value (line 326) | constexpr Value&& value() && noexcept(detail::exceptions_disabled) {
      method Value (line 338) | constexpr const Value&& value() const&& noexcept(detail::exceptions_...
      method err (line 350) | [[nodiscard]] constexpr err assume_error() const noexcept {
      method err (line 360) | constexpr err error() const noexcept(detail::exceptions_disabled) { ...
      method Value (line 374) | constexpr Value value_or(U&& default_value) const& {
      method Value (line 384) | constexpr Value value_or(U&& default_value) && {
    class result<void> (line 399) | class [[nodiscard]] result<void> {
      method result (line 404) | constexpr result() = delete;
      method result (line 410) | constexpr result([[maybe_unused]] decltype(success) s) {}
      method result (line 416) | constexpr result(err error) : error_{error} {
      method result (line 426) | constexpr result(const result<T>& other) {
      method has_value (line 444) | [[nodiscard]] constexpr bool has_value() const noexcept {
      method has_error (line 452) | [[nodiscard]] constexpr bool has_error() const noexcept {
      method assume_value (line 460) | constexpr void assume_value() const noexcept {
      method value (line 469) | constexpr void value() const noexcept(detail::exceptions_disabled) {
      method err (line 480) | [[nodiscard]] constexpr err assume_error() const noexcept {
      method err (line 490) | constexpr err error() const noexcept(detail::exceptions_disabled) { ...
    type detail (line 502) | namespace detail {
      function throw_bad_result_access_or_terminate (line 125) | [[noreturn]] inline void throw_bad_result_access_or_terminate(const ...
      type is_result (line 505) | struct is_result : std::false_type {}
      type is_result<result<T>> (line 508) | struct is_result<result<T>> : std::true_type {}

FILE: include/emio/scan.hpp
  type emio (line 11) | namespace emio {
    function make_scan_args (line 39) | [[nodiscard]] detail::args_storage<detail::scan::scan_arg, sizeof...(A...
    function vscan_from (line 50) | inline result<void> vscan_from(reader& in_rdr, const scan_args& args) ...
    function vscan (line 60) | inline result<void> vscan(std::string_view in, const scan_args& args) ...
    function scan_from (line 77) | constexpr result<void> scan_from(reader& in_rdr, format_scan_string<Ar...
    function scan (line 94) | constexpr result<void> scan(std::string_view input, format_scan_string...

FILE: include/emio/scanner.hpp
  type emio (line 12) | namespace emio {
    class scanner (line 27) | class scanner {
      method scanner (line 30) | scanner() = delete;
      method validate (line 38) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 47) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method scan (line 57) | constexpr result<void> scan(reader& in, T& arg) const noexcept {
    class scanner<T> (line 74) | class scanner<T> {
      method validate (line 76) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 89) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method scan (line 93) | constexpr result<void> scan(reader& in, T& arg) const noexcept {
      method scan (line 111) | constexpr result<void> scan(reader& in, T& arg) noexcept {
    class scanner<T> (line 106) | class scanner<T> : public scanner<detail::upcasted_int_t<T>> {
      method validate (line 76) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 89) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method scan (line 93) | constexpr result<void> scan(reader& in, T& arg) const noexcept {
      method scan (line 111) | constexpr result<void> scan(reader& in, T& arg) noexcept {
    class scanner<std::string_view> (line 126) | class scanner<std::string_view> {
      method validate (line 128) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 135) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method scan (line 141) | constexpr result<void> scan(reader& in, std::string_view& arg) noexc...
    class scanner<std::string> (line 155) | class scanner<std::string> : public scanner<std::string_view> {
      method scan (line 157) | constexpr result<void> scan(reader& in, std::string& arg) noexcept {

FILE: include/emio/std.hpp
  type emio (line 25) | namespace emio {
    class formatter<std::optional<T>> (line 33) | class formatter<std::optional<T>> {
      method validate (line 35) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 39) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 43) | constexpr result<void> format(writer& out, const std::optional<T>& a...
    class formatter<T> (line 63) | class formatter<T> : public formatter<std::string_view> {
      method format (line 65) | result<void> format(writer& out, const std::exception& arg) const no...
    class formatter<std::filesystem::path> (line 75) | class formatter<std::filesystem::path> : public formatter<std::string_...
      method format (line 77) | result<void> format(writer& out, const std::filesystem::path& arg) c...
    class formatter<std::monostate> (line 87) | class formatter<std::monostate> {
      method validate (line 89) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 93) | static constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 97) | static constexpr result<void> format(writer& out, const std::monosta...
    type detail (line 102) | namespace detail {
      function format_escaped_alternative (line 105) | constexpr result<void> format_escaped_alternative(writer& out, const...
    class formatter<std::expected<T, E>> (line 165) | class formatter<std::expected<T, E>> {
      method validate (line 167) | static constexpr result<void> validate(reader& format_rdr) noexcept {
      method parse (line 171) | constexpr result<void> parse(reader& format_rdr) noexcept {
      method format (line 175) | constexpr result<void> format(writer& out, const std::expected<T, E>...
  class formatter<std::variant<Ts...>> (line 128) | class formatter<std::variant<Ts...>> {
    method validate (line 130) | static constexpr result<void> validate(reader& format_rdr) noexcept {
    method parse (line 134) | constexpr result<void> parse(reader& format_rdr) noexcept {
    method format (line 138) | constexpr result<void> format(writer& out, const std::variant<Ts...>& ...

FILE: include/emio/writer.hpp
  type emio (line 15) | namespace emio {
    class writer (line 20) | class writer {
      method writer (line 26) | constexpr writer(buffer& buf) noexcept : buf_{buf} {}
      method buffer (line 32) | [[nodiscard]] constexpr buffer& get_buffer() noexcept {
      method write_char (line 41) | constexpr result<void> write_char(const char c) noexcept {
      method write_char_n (line 53) | constexpr result<void> write_char_n(const char c, const size_t n) no...
      method write_char_escaped (line 69) | constexpr result<void> write_char_escaped(const char c) noexcept {
      method write_str (line 79) | constexpr result<void> write_str(const std::string_view sv) noexcept {
      method write_str_escaped (line 97) | constexpr result<void> write_str_escaped(const std::string_view sv) ...
      type write_int_options (line 104) | struct write_int_options {
      method write_int (line 117) | constexpr result<void> write_int(const T integer,
      method write_int_options (line 126) | static constexpr write_int_options default_write_int_options() noexc...
      method write_int_impl (line 132) | constexpr result<void> write_int_impl(const T integer, const write_i...

FILE: test/compile_test/compile.cpp
  function created_with_span_buffer (line 3) | consteval auto created_with_span_buffer() {
  function created_with_static_buffer (line 9) | consteval auto created_with_static_buffer() {
  function created_with_memory_buffer (line 18) | consteval auto created_with_memory_buffer() {
  function created_with_iterator_buffer (line 27) | consteval auto created_with_iterator_buffer() {
  function main (line 35) | int main() {

FILE: test/fuzzy/dragon4/main.cpp
  type Buffer (line 22) | struct Buffer {
  function print_shortest_header (line 36) | void print_shortest_header(double d) {
  function print_fixed_header (line 40) | void print_fixed_header(double d, int16_t precision) {
  function print_exact_header (line 44) | void print_exact_header(double d, int16_t precision) {
  function print_result (line 49) | void print_result(std::string_view name, std::span<T> digits, int16_t k) {
  function remove_trailing_zeros (line 55) | std::span<T> remove_trailing_zeros(std::span<T> digits) {
  function test_shortest (line 62) | void test_shortest(double d) {
  function test_fixed (line 88) | void test_fixed(double d, int16_t precision) {
  function test_exact (line 120) | void test_exact(double d, int16_t precision) {
  function main (line 156) | int main() {

FILE: test/fuzzy/dragon4/rust_ref/src/lib.rs
  type Buffer (line 15) | struct Buffer {
  function rust_shortest (line 22) | extern "C" fn rust_shortest(d: f64) -> Buffer {
  function rust_fixed (line 44) | extern "C" fn rust_fixed(d: f64, precision: i16) -> Buffer {
  function rust_exponent (line 66) | extern "C" fn rust_exponent(d: f64, limit: i16) -> Buffer {
  function rust_free (line 89) | extern "C" fn rust_free(buf: Buffer) {
  function it_works (line 106) | fn it_works() {

FILE: test/size_test/base.cpp
  function main (line 1) | int main() {}

FILE: test/size_test/emio/doFormat_a.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_all.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_all_and_extra.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_and_scan_all.cpp
  function main (line 3) | int main(int /*c*/, char* args[]) {

FILE: test/size_test/emio/format_and_scan_all_runtime.cpp
  function main (line 3) | int main(int /*c*/, char* args[]) {

FILE: test/size_test/emio/format_and_write_int.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_double.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_int.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_int_twice.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_runtime.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/format_to.cpp
  function main (line 4) | int main() {

FILE: test/size_test/emio/format_to_n.cpp
  function main (line 4) | int main() {

FILE: test/size_test/emio/scan_all.cpp
  function main (line 3) | int main(int /*c*/, char* args[]) {

FILE: test/size_test/emio/scan_int.cpp
  function main (line 3) | int main(int /*c*/, char* args[]) {

FILE: test/size_test/emio/vformat.cpp
  function main (line 3) | int main() {

FILE: test/size_test/emio/write_int.cpp
  function main (line 3) | int main() {

FILE: test/size_test/fmt/doFormat_a.cpp
  function main (line 5) | int main() {

FILE: test/size_test/fmt/fmt_dragon.cpp
  function main (line 3) | int main(int c, char*[] /*unused*/) {

FILE: test/size_test/fmt/fmt_grisu.cpp
  function main (line 3) | int main(int c, char*[] /*unused*/) {

FILE: test/size_test/fmt/fmt_grisu_and_dragon.cpp
  function main (line 3) | int main(int c, char*[] /*unused*/) {

FILE: test/size_test/fmt/format_all.cpp
  function main (line 3) | int main() {

FILE: test/size_test/fmt/format_all_and_extra.cpp
  function main (line 6) | int main() {

FILE: test/size_test/fmt/format_int.cpp
  function main (line 3) | int main() {

FILE: test/size_test/fmt/format_int_twice.cpp
  function main (line 3) | int main() {

FILE: test/size_test/fmt/format_runtime.cpp
  function main (line 3) | int main() {

FILE: test/size_test/fmt/format_to.cpp
  function main (line 5) | int main() {

FILE: test/size_test/fmt/format_to_n.cpp
  function main (line 5) | int main() {

FILE: test/size_test/fmt/vformat.cpp
  function main (line 3) | int main() {

FILE: test/size_test/std/locale.cpp
  function main (line 3) | int main() {

FILE: test/size_test/std/snprintf.cpp
  function main (line 5) | int main(int c, char* args[]) {

FILE: test/size_test/std/snprintf_and_sscanf.cpp
  function main (line 5) | int main(int c, char* args[]) {

FILE: test/size_test/std/sscanf.cpp
  function main (line 5) | int main(int /*c*/, char* args[]) {

FILE: test/size_test/std/string.cpp
  function main (line 3) | int main() {

FILE: test/size_test/std/string_stream.cpp
  function main (line 3) | int main() {

FILE: test/size_test/std/to_chars.cpp
  function main (line 4) | int main() {

FILE: test/size_test/std/to_string_double.cpp
  function main (line 3) | int main() {

FILE: test/size_test/std/to_string_int.cpp
  function main (line 3) | int main() {

FILE: test/size_test/stubs.cpp
  function _exit (line 3) | void _exit(int /*unused*/) {
  function _getpid (line 8) | int _getpid() {
  function _kill (line 12) | int _kill(int /*unused*/, int /*unused*/) {
  function _isatty (line 20) | int _isatty(int /*unused*/) {
  function _lseek (line 24) | int _lseek(int /*unused*/, int /*unused*/, int /*unused*/) {
  type stat (line 28) | struct stat
  function _fstat (line 30) | int _fstat(int /*unused*/, struct stat* /*st*/) {
  function _read (line 34) | int _read(int /*unused*/, void* /*unused*/) {
  function _write (line 38) | int _write(int /*unused*/, void* /*unused*/) {
  function _close (line 42) | int _close(int /*unused*/) {
  type __cxxabiv1 (line 49) | namespace __cxxabiv1 {

FILE: test/static_analysis/test_main.cpp
  function compile_time_test (line 4) | consteval emio::result<void> compile_time_test() {
  function test (line 10) | emio::result<void> test() {
  function main (line 21) | int main() {

FILE: test/unit_test/detail/test_ct_vector.cpp
  function check_equality_of_vector (line 15) | void check_equality_of_vector(T& expected, T& other) {
  function check_gang_of_5 (line 42) | void check_gang_of_5(T& buf) {

FILE: test/unit_test/detail/test_dragon.cpp
  function check_exact_one (line 10) | static void check_exact_one(const emf::finite_result_t& decoded, std::st...
  function check_shortest (line 127) | void check_shortest(double d, std::string_view expected_str, int16_t exp...
  function check_fixed (line 204) | void check_fixed(const emf::finite_result_t& finite, int16_t precision, ...
  function check_exponent (line 213) | void check_exponent(const emf::finite_result_t& finite, int16_t precisio...

FILE: test/unit_test/detail/test_utf.cpp
  function test_escape (line 9) | [[nodiscard]] bool test_escape(std::string_view input, std::string_view ...

FILE: test/unit_test/integer_ranges.hpp
  type emio::test (line 6) | namespace emio::test {
    function apply_integer_ranges (line 57) | constexpr void apply_integer_ranges(T&& func) {

FILE: test/unit_test/test_buffer.cpp
  function fill (line 11) | constexpr void fill(const emio::result<std::span<char>>& area, char v) {
  function check_equality_of_buffer (line 16) | constexpr bool check_equality_of_buffer(T& expected, T& other, bool data...
  function check_gang_of_5 (line 79) | void check_gang_of_5(T& buf, bool data_ptr_is_different) {
  class dummy_span_buffer (line 402) | class dummy_span_buffer : public emio::span_buffer {

FILE: test/unit_test/test_dynamic_format_spec.cpp
  class no_copy_or_move (line 12) | class no_copy_or_move {
    method no_copy_or_move (line 14) | no_copy_or_move() = default;
    method no_copy_or_move (line 15) | no_copy_or_move(const no_copy_or_move&) = delete;
    method no_copy_or_move (line 16) | no_copy_or_move(no_copy_or_move&&) = delete;
    method no_copy_or_move (line 17) | no_copy_or_move& operator=(const no_copy_or_move&) = delete;
    method no_copy_or_move (line 18) | no_copy_or_move& operator=(no_copy_or_move&&) = delete;
  function format_as (line 21) | constexpr auto format_as(const no_copy_or_move& /*unused*/) {

FILE: test/unit_test/test_format.cpp
  function validate_format_string (line 16) | bool validate_format_string(std::string_view str) {
  function function_pointer_test (line 739) | void function_pointer_test(int, double, std::string) {}
  type color (line 780) | enum color { red, green, blue }
  type string_viewable (line 818) | struct string_viewable {}
  type formatter<string_viewable> (line 822) | struct formatter<string_viewable> : formatter<std::string_view> {
    method format (line 823) | auto format(string_viewable, format_context& ctx) -> decltype(ctx.out(...
  function FMT_END_NAMESPACE (line 827) | FMT_END_NAMESPACE
  type explicitly_convertible_to_std_string_view (line 834) | struct explicitly_convertible_to_std_string_view {
  type fmt::formatter<explicitly_convertible_to_std_string_view> (line 841) | struct fmt::formatter<explicitly_convertible_to_std_string_view> : forma...
    method format (line 842) | auto format(explicitly_convertible_to_std_string_view v, format_contex...
  function TEST (line 847) | TEST(format_test, format_explicitly_convertible_to_std_string_view) {

FILE: test/unit_test/test_format_as.cpp
  type foo (line 7) | namespace foo {
    type bar (line 9) | enum class bar {}
    function format_as (line 11) | constexpr auto format_as(const bar& w) {

FILE: test/unit_test/test_formatter.cpp
  type wrap (line 9) | struct wrap {
  class emio::formatter<wrap> (line 16) | class emio::formatter<wrap> : public emio::formatter<int> {
    method format (line 18) | constexpr result<void> format(writer& out, const wrap& arg) const noex...
  type foo (line 55) | struct foo {
  class emio::formatter<foo> (line 62) | class emio::formatter<foo> {
    method validate (line 64) | static constexpr result<void> validate(reader& rdr) noexcept {
    method parse (line 75) | constexpr result<void> parse(reader& rdr) noexcept {
    method format (line 87) | constexpr result<void> format(writer& out, const foo& arg) const noexc...
  type bar (line 136) | struct bar {}
  class emio::formatter<bar> (line 141) | class emio::formatter<bar> {
    method validate (line 143) | static result<void> validate(reader& rdr) noexcept {
    method parse (line 154) | result<void> parse(reader& rdr) noexcept {
    method format (line 166) | result<void> format(writer& out, const bar& /*arg*/) const noexcept {
  type foobar (line 189) | struct foobar {
  class emio::formatter<foobar> (line 196) | class emio::formatter<foobar> {
    method parse (line 198) | constexpr result<void> parse(reader& rdr) noexcept {
    method format (line 210) | constexpr result<void> format(writer& out, const foobar& arg) const no...
  type bazz0 (line 259) | struct bazz0 {}
  type bazz1 (line 260) | struct bazz1 {}
  type bazz2 (line 261) | struct bazz2 {}
  type bazz3 (line 262) | struct bazz3 {}
  class emio::formatter<bazz0> (line 267) | class emio::formatter<bazz0> {
  class emio::formatter<bazz1> (line 273) | class emio::formatter<bazz1> {
  class emio::formatter<bazz2> (line 279) | class emio::formatter<bazz2> {
  class emio::formatter<bazz3> (line 285) | class emio::formatter<bazz3> {
  type f1 (line 314) | struct f1 {}
  type f2 (line 315) | struct f2 {}
  type f3 (line 316) | struct f3 {}
  class emio::formatter<f1> (line 320) | class emio::formatter<f1> {
  class emio::formatter<f2> (line 325) | class emio::formatter<f2> {
  class emio::formatter<f3> (line 331) | class emio::formatter<f3> {

FILE: test/unit_test/test_ranges.cpp
  type adl (line 85) | namespace adl {
    type box (line 86) | struct box {
    function begin (line 90) | auto begin(const box& b) -> const int* {
    function end (line 94) | auto end(const box& b) -> const int* {
  type unformattable (line 124) | struct unformattable {}
  type tuple_like (line 141) | struct tuple_like {
    method get (line 147) | int get() const noexcept {
    method get (line 152) | std::string_view get() const noexcept {
  function get (line 158) | auto get(const tuple_like& t) noexcept -> decltype(t.get<N>()) {
  type std (line 162) | namespace std {
    type tuple_size<tuple_like> (line 164) | struct tuple_size<tuple_like> : std::integral_constant<size_t, 2> {}
    type tuple_element<N, tuple_like> (line 167) | struct tuple_element<N, tuple_like> {

FILE: test/unit_test/test_scan.cpp
  function validate_scan_string (line 12) | bool validate_scan_string(std::string_view str) {

FILE: test/unit_test/test_std.cpp
  type unformattable (line 9) | struct unformattable {}
  type throws_on_move (line 42) | struct throws_on_move {
    method throws_on_move (line 43) | throws_on_move() = default;
    method throws_on_move (line 44) | throws_on_move(throws_on_move&&) {
  function format_as (line 49) | std::string_view format_as(const throws_on_move&) {

FILE: test/unit_test/test_writer.cpp
  class buffer_from_cb (line 12) | class buffer_from_cb : public emio::buffer {
    method set_cache_cb (line 14) | void set_cache_cb(std::function<std::span<char>()> cache_cb) noexcept {
    method request_write_area (line 18) | emio::result<std::span<char>> request_write_area(const size_t /*used*/...