#include <array>
#include <dwarfs/tool/manpage.h>

namespace dwarfs::tool::manpage {

// NOLINTBEGIN(readability-*)

namespace {
#if 0
Heading(1, dwarfs(1) -- mount highly compressed read-only file system, None)
#endif
constexpr uint32_t const line0_indent_first{0};
constexpr uint32_t const line0_indent_next{0};
constexpr std::array<element, 1> const line0_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h1', 'head'} */, R"(dwarfs(1) -- mount highly compressed read-only file system)"} /* raw text */,
}};

constexpr uint32_t const line1_indent_first{0};
constexpr uint32_t const line1_indent_next{0};
constexpr std::array<element, 0> const line1_elements{{
}};

#if 0
Heading(2, SYNOPSIS, None)
#endif
constexpr uint32_t const line2_indent_first{0};
constexpr uint32_t const line2_indent_next{0};
constexpr std::array<element, 1> const line2_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(SYNOPSIS)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190b81400>
#endif
// paragraph
constexpr uint32_t const line3_indent_first{8};
constexpr uint32_t const line3_indent_next{8};
constexpr std::array<element, 8> const line3_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(image)"} /* raw text */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(mountpoint)"} /* raw text */,
    {{} /* set() */, R"( [)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(options)"} /* raw text */,
    {{} /* set() */, R"(...])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line4_indent_first{8};
constexpr uint32_t const line4_indent_next{8};
constexpr std::array<element, 6> const line4_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( --auto-mountpoint )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(image)"} /* raw text */,
    {{} /* set() */, R"( [)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(options)"} /* raw text */,
    {{} /* set() */, R"(...])"} /* raw text */,
}};

constexpr uint32_t const line5_indent_first{0};
constexpr uint32_t const line5_indent_next{0};
constexpr std::array<element, 0> const line5_elements{{
}};

#if 0
Heading(2, DESCRIPTION, None)
#endif
constexpr uint32_t const line6_indent_first{0};
constexpr uint32_t const line6_indent_next{0};
constexpr std::array<element, 1> const line6_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(DESCRIPTION)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190c82e90>
#endif
// paragraph
constexpr uint32_t const line7_indent_first{8};
constexpr uint32_t const line7_indent_next{8};
constexpr std::array<element, 6> const line7_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( is the FUSE driver for DwarFS, a highly compressed, read-only file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system. As such, it's similar to file systems like SquashFS, cramfs or CromFS,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(but it has some distinct features.)"} /* raw text */,
}};

constexpr uint32_t const line8_indent_first{0};
constexpr uint32_t const line8_indent_next{0};
constexpr std::array<element, 0> const line8_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190c834d0>
#endif
// paragraph
constexpr uint32_t const line9_indent_first{8};
constexpr uint32_t const line9_indent_next{8};
constexpr std::array<element, 3> const line9_elements{{
    {{} /* set() */, R"(Other than that, it's pretty straightforward to use. Once you've created a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file system image using mkdwarfs(1), you can mount it with:)"} /* raw text */,
}};

constexpr uint32_t const line10_indent_first{0};
constexpr uint32_t const line10_indent_next{0};
constexpr std::array<element, 0> const line10_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190b81400>
#endif
// raw text
constexpr uint32_t const line11_indent_first{12};
constexpr uint32_t const line11_indent_next{12};
constexpr std::array<element, 1> const line11_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs image.dwarfs /path/to/mountpoint)"} /* None */,
}};

// raw text
constexpr uint32_t const line12_indent_first{12};
constexpr uint32_t const line12_indent_next{12};
constexpr std::array<element, 1> const line12_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190b788a0>
#endif
// paragraph
constexpr uint32_t const line13_indent_first{8};
constexpr uint32_t const line13_indent_next{8};
constexpr std::array<element, 11> const line13_elements{{
    {{} /* set() */, R"(Alternatively, you can use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--auto-mountpoint)"} /* inline code */,
    {{} /* set() */, R"( option to use a directory)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(with the same path and base name as the image file as the mount point. If)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that directory doesn't exist, it will be created automatically. If it was)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(created automatically, it will also be removed again when the file system is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(unmounted.)"} /* raw text */,
}};

constexpr uint32_t const line14_indent_first{0};
constexpr uint32_t const line14_indent_next{0};
constexpr std::array<element, 0> const line14_elements{{
}};

#if 0
Heading(2, OPTIONS, None)
#endif
constexpr uint32_t const line15_indent_first{0};
constexpr uint32_t const line15_indent_next{0};
constexpr std::array<element, 1> const line15_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(OPTIONS)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190b788a0>
#endif
// paragraph
constexpr uint32_t const line16_indent_first{8};
constexpr uint32_t const line16_indent_next{8};
constexpr std::array<element, 5> const line16_elements{{
    {{} /* set() */, R"(In addition to the regular FUSE options, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( supports the following)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(options:)"} /* raw text */,
}};

constexpr uint32_t const line17_indent_first{0};
constexpr uint32_t const line17_indent_next{0};
constexpr std::array<element, 0> const line17_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7fc190ca9490>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b0c490>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b0dbf0>], list item), ListItem([<__main__.Paragraph object at 0x7fc190cbce50>], list item), ListItem([<__main__.Paragraph object at 0x7fc190cbd050>], list item), ListItem([<__main__.Paragraph object at 0x7fc190cba120>], list item), ListItem([<__main__.Paragraph object at 0x7fc190cbb6b0>], list item), ListItem([<__main__.Paragraph object at 0x7fc19093cc90>], list item), ListItem([<__main__.Paragraph object at 0x7fc19093d550>], list item), ListItem([<__main__.Paragraph object at 0x7fc190d24c80>], list item), ListItem([<__main__.Paragraph object at 0x7fc190c8eed0>], list item), ListItem([<__main__.Paragraph object at 0x7fc190c8ef90>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b9d860>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b9e200>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b41f90>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b42850>], list item), ListItem([<__main__.Paragraph object at 0x7fc190dfb770>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b4a6d0>], list item), ListItem([<__main__.Paragraph object at 0x7fc190b4a850>], list item), ListItem([<__main__.Paragraph object at 0x7fc190c2fa80>], list item), ListItem([<__main__.Paragraph object at 0x7fc190d5eeb0>], list item), ListItem([<__main__.Paragraph object at 0x7fc190954a10>], list item), ListItem([<__main__.Paragraph object at 0x7fc1909550d0>], list item), ListItem([<__main__.Paragraph object at 0x7fc1909559d0>], list item), ListItem([<__main__.Paragraph object at 0x7fc190955d90>], list item), ListItem([<__main__.Paragraph object at 0x7fc190956270>], list item)]
#endif
// paragraph
constexpr uint32_t const line18_indent_first{8};
constexpr uint32_t const line18_indent_next{8};
constexpr std::array<element, 3> const line18_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o cachesize=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line19_indent_first{16};
constexpr uint32_t const line19_indent_next{16};
constexpr std::array<element, 21> const line19_elements{{
    {{} /* set() */, R"(Size of the block cache, in bytes. You can append suffixes)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(k)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(m)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(g)"} /* inline code */,
    {{} /* set() */, R"() to specify the size in KiB, MiB and GiB,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(respectively. Note that this is not the upper memory limit)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of the process, as there may be blocks in flight that are)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(not stored in the cache. Also, each block that hasn't been)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fully decompressed yet will carry decompressor state along)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(with it, which can use a significant amount of additional)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(memory. For more details, see mkdwarfs(1).)"} /* raw text */,
}};

constexpr uint32_t const line20_indent_first{0};
constexpr uint32_t const line20_indent_next{0};
constexpr std::array<element, 0> const line20_elements{{
}};

// paragraph
constexpr uint32_t const line21_indent_first{8};
constexpr uint32_t const line21_indent_next{8};
constexpr std::array<element, 3> const line21_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o blocksize=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line22_indent_first{16};
constexpr uint32_t const line22_indent_next{16};
constexpr std::array<element, 5> const line22_elements{{
    {{} /* set() */, R"(Size reported for files in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(st_blksize)"} /* inline code */,
    {{} /* set() */, R"(. You can use this to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(optimize throughput in certain situations.)"} /* raw text */,
}};

constexpr uint32_t const line23_indent_first{0};
constexpr uint32_t const line23_indent_next{0};
constexpr std::array<element, 0> const line23_elements{{
}};

// paragraph
constexpr uint32_t const line24_indent_first{8};
constexpr uint32_t const line24_indent_next{8};
constexpr std::array<element, 3> const line24_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o readahead=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line25_indent_first{16};
constexpr uint32_t const line25_indent_next{16};
constexpr std::array<element, 7> const line25_elements{{
    {{} /* set() */, R"(How much data to read ahead when receiving a read request.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(This is experimental and disabled by default. If you perform)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(a lot of large, sequential reads, throughput may benefit from)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(enabling readahead.)"} /* raw text */,
}};

constexpr uint32_t const line26_indent_first{0};
constexpr uint32_t const line26_indent_next{0};
constexpr std::array<element, 0> const line26_elements{{
}};

// paragraph
constexpr uint32_t const line27_indent_first{8};
constexpr uint32_t const line27_indent_next{8};
constexpr std::array<element, 3> const line27_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o workers=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line28_indent_first{16};
constexpr uint32_t const line28_indent_next{16};
constexpr std::array<element, 5> const line28_elements{{
    {{} /* set() */, R"(Number of worker threads to use for decompressing blocks.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If you have a lot of CPUs, increasing this number can help)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(speed up access to files in the filesystem.)"} /* raw text */,
}};

constexpr uint32_t const line29_indent_first{0};
constexpr uint32_t const line29_indent_next{0};
constexpr std::array<element, 0> const line29_elements{{
}};

// paragraph
constexpr uint32_t const line30_indent_first{8};
constexpr uint32_t const line30_indent_next{8};
constexpr std::array<element, 3> const line30_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o uid=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(num)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line31_indent_first{16};
constexpr uint32_t const line31_indent_next{16};
constexpr std::array<element, 3> const line31_elements{{
    {{} /* set() */, R"(Override the user ID for the whole file system. This option)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is not supported on Windows.)"} /* raw text */,
}};

constexpr uint32_t const line32_indent_first{0};
constexpr uint32_t const line32_indent_next{0};
constexpr std::array<element, 0> const line32_elements{{
}};

// paragraph
constexpr uint32_t const line33_indent_first{8};
constexpr uint32_t const line33_indent_next{8};
constexpr std::array<element, 3> const line33_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o gid=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(num)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line34_indent_first{16};
constexpr uint32_t const line34_indent_next{16};
constexpr std::array<element, 3> const line34_elements{{
    {{} /* set() */, R"(Override the group ID for the whole file system. This option)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is not supported on Windows.)"} /* raw text */,
}};

constexpr uint32_t const line35_indent_first{0};
constexpr uint32_t const line35_indent_next{0};
constexpr std::array<element, 0> const line35_elements{{
}};

// paragraph
constexpr uint32_t const line36_indent_first{8};
constexpr uint32_t const line36_indent_next{8};
constexpr std::array<element, 3> const line36_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o decratio=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line37_indent_first{16};
constexpr uint32_t const line37_indent_next{16};
constexpr std::array<element, 21> const line37_elements{{
    {{} /* set() */, R"(The ratio over which a block is fully decompressed. Blocks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(are only decompressed partially, so each block has to carry)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the decompressor state with it until it is fully decompressed.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(However, if a certain fraction of the block has already been)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(decompressed, it may be beneficial to just decompress the rest)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and free the decompressor state. This value determines the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(ratio at which we fully decompress the block rather than)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(keeping a partially decompressed block. A value of 0.8 means)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that as long as we've decompressed less than 80% of the block,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(we keep the partially decompressed block, but if we've)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(decompressed more then 80%, we'll fully decompress it.)"} /* raw text */,
}};

constexpr uint32_t const line38_indent_first{0};
constexpr uint32_t const line38_indent_next{0};
constexpr std::array<element, 0> const line38_elements{{
}};

// paragraph
constexpr uint32_t const line39_indent_first{8};
constexpr uint32_t const line39_indent_next{8};
constexpr std::array<element, 5> const line39_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o offset=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(auto)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line40_indent_first{16};
constexpr uint32_t const line40_indent_next{16};
constexpr std::array<element, 9> const line40_elements{{
    {{} /* set() */, R"(Specify the byte offset at which the filesystem is located in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the image, or use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(auto)"} /* inline code */,
    {{} /* set() */, R"( to detect the offset automatically.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(This is only useful for images that have some header located)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(before the actual filesystem data.)"} /* raw text */,
}};

constexpr uint32_t const line41_indent_first{0};
constexpr uint32_t const line41_indent_next{0};
constexpr std::array<element, 0> const line41_elements{{
}};

// paragraph
constexpr uint32_t const line42_indent_first{8};
constexpr uint32_t const line42_indent_next{8};
constexpr std::array<element, 3> const line42_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o imagesize=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line43_indent_first{16};
constexpr uint32_t const line43_indent_next{16};
constexpr std::array<element, 5> const line43_elements{{
    {{} /* set() */, R"(Explicitly set the size of the filesystem image in bytes,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(starting from the offset. This can be used in cases where)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the image is embedded in a larger file.)"} /* raw text */,
}};

constexpr uint32_t const line44_indent_first{0};
constexpr uint32_t const line44_indent_next{0};
constexpr std::array<element, 0> const line44_elements{{
}};

// paragraph
constexpr uint32_t const line45_indent_first{8};
constexpr uint32_t const line45_indent_next{8};
constexpr std::array<element, 6> const line45_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o mlock=none)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(try)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(must)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line46_indent_first{16};
constexpr uint32_t const line46_indent_next{16};
constexpr std::array<element, 13> const line46_elements{{
    {{} /* set() */, R"(Set this to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(try)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(must)"} /* inline code */,
    {{} /* set() */, R"( instead of the default )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"( to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(try or require )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mlock())"} /* inline code */,
    {{} /* set() */, R"(ing of the file system metadata into)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(memory.)"} /* raw text */,
}};

constexpr uint32_t const line47_indent_first{0};
constexpr uint32_t const line47_indent_next{0};
constexpr std::array<element, 0> const line47_elements{{
}};

// paragraph
constexpr uint32_t const line48_indent_first{8};
constexpr uint32_t const line48_indent_next{8};
constexpr std::array<element, 2> const line48_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o readonly)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line49_indent_first{16};
constexpr uint32_t const line49_indent_next{16};
constexpr std::array<element, 15> const line49_elements{{
    {{} /* set() */, R"(Show all file system entries as read-only. By default, DwarFS)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will preserve the original writability, which is obviously a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(lie as it's a read-only file system. However, this is needed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for overlays to work correctly, as otherwise directories are)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(seen as read-only by the overlay and it'll be impossible to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(create new files even in a writeable overlay. If you don't use)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(overlays and want the file system to reflect its read-only)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(state, you can set this option.)"} /* raw text */,
}};

constexpr uint32_t const line50_indent_first{0};
constexpr uint32_t const line50_indent_next{0};
constexpr std::array<element, 0> const line50_elements{{
}};

// paragraph
constexpr uint32_t const line51_indent_first{8};
constexpr uint32_t const line51_indent_next{8};
constexpr std::array<element, 2> const line51_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o case_insensitive)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line52_indent_first{16};
constexpr uint32_t const line52_indent_next{16};
constexpr std::array<element, 24> const line52_elements{{
    {{} /* set() */, R"(Perform case-insensitive lookups in the mounted file system,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(i.e. an entry originally named )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ReadMe.txt)"} /* inline code */,
    {{} /* set() */, R"( can be accessed as)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(readme.txt)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(README.TXT)"} /* inline code */,
    {{} /* set() */, R"(, or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(rEaDmE.tXt)"} /* inline code */,
    {{} /* set() */, R"(. This works across)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(all platforms. When mounting a file system with many files, this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(may be slightly slower and consume slightly more memory as case-)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(insensitive lookup requires an additional mapping table that is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(built on-demand. Note that this is not supported if the file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system contains directories with entries that only differ in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(case.)"} /* raw text */,
}};

constexpr uint32_t const line53_indent_first{0};
constexpr uint32_t const line53_indent_next{0};
constexpr std::array<element, 0> const line53_elements{{
}};

// paragraph
constexpr uint32_t const line54_indent_first{8};
constexpr uint32_t const line54_indent_next{8};
constexpr std::array<element, 3> const line54_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o preload_category=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(category)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line55_indent_first{16};
constexpr uint32_t const line55_indent_next{16};
constexpr std::array<element, 8> const line55_elements{{
    {{} /* set() */, R"(Preload all blocks from this category when mounting the file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system. This is typically used together with the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"("hotness" categorizer. If the cache size is too small, only as)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(many blocks as will fit in the cache will be preloaded.)"} /* raw text */,
}};

constexpr uint32_t const line56_indent_first{0};
constexpr uint32_t const line56_indent_next{0};
constexpr std::array<element, 0> const line56_elements{{
}};

// paragraph
constexpr uint32_t const line57_indent_first{8};
constexpr uint32_t const line57_indent_next{8};
constexpr std::array<element, 15> const line57_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o preload_all)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Preload )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(all)"} /* raw text */,
    {{} /* set() */, R"( blocks from the file system. This is only useful)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for file systems where all uncompressed blocks fit fully into)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the configured cache size. To see the uncompressed block size,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you can use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfsck)"} /* inline code */,
    {{} /* set() */, R"(. If the cache size is too small, only as)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(many blocks as will fit in the cache will be preloaded.)"} /* raw text */,
}};

constexpr uint32_t const line58_indent_first{0};
constexpr uint32_t const line58_indent_next{0};
constexpr std::array<element, 0> const line58_elements{{
}};

// paragraph
constexpr uint32_t const line59_indent_first{8};
constexpr uint32_t const line59_indent_next{8};
constexpr std::array<element, 2> const line59_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o (no_)cache_files)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line60_indent_first{16};
constexpr uint32_t const line60_indent_next{16};
constexpr std::array<element, 22> const line60_elements{{
    {{} /* set() */, R"(By default, files in the mounted file system will be cached by)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the kernel (i.e. the default is )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o cache_files)"} /* inline code */,
    {{} /* set() */, R"(). This will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(significantly improve performance when accessing the same files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(over and over again, especially if the data from these files has)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(been (partially) evicted from the block cache. By setting the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o no_cache_files)"} /* inline code */,
    {{} /* set() */, R"( option, you can force the fuse driver to not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(use the kernel cache for file data. If you're short on memory and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(only infrequently accessing files, this can be worth trying, even)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(though it's likely that the kernel will already do the right thing)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(even when the cache is enabled.)"} /* raw text */,
}};

constexpr uint32_t const line61_indent_first{0};
constexpr uint32_t const line61_indent_next{0};
constexpr std::array<element, 0> const line61_elements{{
}};

// paragraph
constexpr uint32_t const line62_indent_first{8};
constexpr uint32_t const line62_indent_next{8};
constexpr std::array<element, 2> const line62_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o (no_)cache_sparse)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line63_indent_first{16};
constexpr uint32_t const line63_indent_next{16};
constexpr std::array<element, 21> const line63_elements{{
    {{} /* set() */, R"(If a file system image contains sparse files, these will not be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(cached by default (i.e. the default is )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o no_cache_sparse)"} /* inline code */,
    {{} /* set() */, R"().)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(It is assumed that sparse files are typically large and mostly)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(filled with zeros, so caching them is quite wasteful. Also, if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you have tools that don't treat sparse files different from)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(non-sparse files, enabling caching will slow down reads quite)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(significantly due to the overhead of caching. )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(If)"} /* raw text */,
    {{} /* set() */, R"( your tools)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(handle sparse files properly, you can safely enable caching and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(it will potentially improve performance.)"} /* raw text */,
}};

constexpr uint32_t const line64_indent_first{0};
constexpr uint32_t const line64_indent_next{0};
constexpr std::array<element, 0> const line64_elements{{
}};

// paragraph
constexpr uint32_t const line65_indent_first{8};
constexpr uint32_t const line65_indent_next{8};
constexpr std::array<element, 3> const line65_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o debuglevel=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(name)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line66_indent_first{16};
constexpr uint32_t const line66_indent_next{16};
constexpr std::array<element, 26> const line66_elements{{
    {{} /* set() */, R"(Use this for different levels of verbosity along with either)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-f)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-d)"} /* inline code */,
    {{} /* set() */, R"( FUSE options. This can give you some insight)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(over what the file system driver is doing internally, but it's)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(mainly meant for debugging and the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(debug)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(trace)"} /* inline code */,
    {{} /* set() */, R"( levels)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in particular will slow down the driver. This defaults to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(info)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in foreground mode ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-f)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-d)"} /* inline code */,
    {{} /* set() */, R"() and to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(warn)"} /* inline code */,
    {{} /* set() */, R"( in background mode.)"} /* raw text */,
}};

constexpr uint32_t const line67_indent_first{0};
constexpr uint32_t const line67_indent_next{0};
constexpr std::array<element, 0> const line67_elements{{
}};

// paragraph
constexpr uint32_t const line68_indent_first{8};
constexpr uint32_t const line68_indent_next{8};
constexpr std::array<element, 3> const line68_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o analysis_file=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line69_indent_first{16};
constexpr uint32_t const line69_indent_next{16};
constexpr std::array<element, 14> const line69_elements{{
    {{} /* set() */, R"(Write the paths of all files that were opened while the file system)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(image was mounted to this file. This can be used as a set of "hot")"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(files for the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hotness)"} /* inline code */,
    {{} /* set() */, R"( categorizer in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"(. See the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(documentation for details on producing images optimized for fast)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(access times after mounting.)"} /* raw text */,
}};

constexpr uint32_t const line70_indent_first{0};
constexpr uint32_t const line70_indent_next{0};
constexpr std::array<element, 0> const line70_elements{{
}};

// paragraph
constexpr uint32_t const line71_indent_first{8};
constexpr uint32_t const line71_indent_next{8};
constexpr std::array<element, 6> const line71_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o tidy_strategy=none)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(time)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(swap)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line72_indent_first{16};
constexpr uint32_t const line72_indent_next{16};
constexpr std::array<element, 30> const line72_elements{{
    {{} /* set() */, R"(Use one of the following strategies to tidy the block cache.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"( is the default strategy that never tidies the cache. Blocks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will only be evicted from the cache if the cache is full and a more)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(recently used block is added to the cache. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(time)"} /* inline code */,
    {{} /* set() */, R"( enables a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(time-based tidying strategy. Every )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_interval)"} /* inline code */,
    {{} /* set() */, R"(, the block cache)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is traversed and all blocks that have not been accessed for more)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(than )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_max_age)"} /* inline code */,
    {{} /* set() */, R"( will be removed. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(swap)"} /* inline code */,
    {{} /* set() */, R"( enables a swap-based)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(tidying strategy. Every )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_interval)"} /* inline code */,
    {{} /* set() */, R"(, the block cache is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(traversed and all blocks that have been fully or partially swapped)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(out by the kernel will be removed.)"} /* raw text */,
}};

constexpr uint32_t const line73_indent_first{0};
constexpr uint32_t const line73_indent_next{0};
constexpr std::array<element, 0> const line73_elements{{
}};

// paragraph
constexpr uint32_t const line74_indent_first{8};
constexpr uint32_t const line74_indent_next{8};
constexpr std::array<element, 3> const line74_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o tidy_interval=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(time)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line75_indent_first{16};
constexpr uint32_t const line75_indent_next{16};
constexpr std::array<element, 21> const line75_elements{{
    {{} /* set() */, R"(Used only if )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_strategy)"} /* inline code */,
    {{} /* set() */, R"( is not )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"(. This is the interval)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(at which the cache tidying thread wakes up to look for blocks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that can be removed from the cache. This must be an integer value.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Suffixes )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ms)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(s)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(m)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(h)"} /* inline code */,
    {{} /* set() */, R"( are supported. If no suffix is given,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the value will be assumed to be in seconds.)"} /* raw text */,
}};

constexpr uint32_t const line76_indent_first{0};
constexpr uint32_t const line76_indent_next{0};
constexpr std::array<element, 0> const line76_elements{{
}};

// paragraph
constexpr uint32_t const line77_indent_first{8};
constexpr uint32_t const line77_indent_next{8};
constexpr std::array<element, 3> const line77_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o tidy_max_age=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(time)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line78_indent_first{16};
constexpr uint32_t const line78_indent_next{16};
constexpr std::array<element, 19> const line78_elements{{
    {{} /* set() */, R"(Used only if )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_strategy)"} /* inline code */,
    {{} /* set() */, R"( is )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(time)"} /* inline code */,
    {{} /* set() */, R"(. A block will be removed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(from the cache if it hasn't been used for this time span. This must)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be an integer value. Suffixes )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ms)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(s)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(m)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(h)"} /* inline code */,
    {{} /* set() */, R"( are supported.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If no suffix is given, the value will be assumed to be in seconds.)"} /* raw text */,
}};

constexpr uint32_t const line79_indent_first{0};
constexpr uint32_t const line79_indent_next{0};
constexpr std::array<element, 0> const line79_elements{{
}};

// paragraph
constexpr uint32_t const line80_indent_first{8};
constexpr uint32_t const line80_indent_next{8};
constexpr std::array<element, 4> const line80_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o block_allocator=malloc)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mmap)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line81_indent_first{16};
constexpr uint32_t const line81_indent_next{16};
constexpr std::array<element, 31> const line81_elements{{
    {{} /* set() */, R"(Select the allocator for decompressed file system blocks. By default,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(blocks will be allocated using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(malloc)"} /* inline code */,
    {{} /* set() */, R"(. However, depending on the way)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(malloc)"} /* inline code */,
    {{} /* set() */, R"( is implemented on your system, you may find that memory)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(used by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( isn't released despite using cache tidying. In this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(case, using the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mmap)"} /* inline code */,
    {{} /* set() */, R"( block allocator is much more likely to release)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the memory. Note, however, that the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mmap)"} /* inline code */,
    {{} /* set() */, R"( allocator can be slower than)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(malloc)"} /* inline code */,
    {{} /* set() */, R"( allocator. If your use case causes large numbers of blocks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to be constantly created/evicted (e.g. you have a huge image and are)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(randomly accessing a large fraction of the files), this may impact the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(performance.)"} /* raw text */,
}};

constexpr uint32_t const line82_indent_first{0};
constexpr uint32_t const line82_indent_next{0};
constexpr std::array<element, 0> const line82_elements{{
}};

// paragraph
constexpr uint32_t const line83_indent_first{8};
constexpr uint32_t const line83_indent_next{8};
constexpr std::array<element, 3> const line83_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o seq_detector=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(num)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line84_indent_first{16};
constexpr uint32_t const line84_indent_next{16};
constexpr std::array<element, 13> const line84_elements{{
    {{} /* set() */, R"(Threshold, in blocks, for the sequential access detector. If the most)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(recently accessed )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(num)"} /* raw text */,
    {{} /* set() */, R"( blocks are sequential, then the block following)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the sequence is prefetched. This can significantly increase throughput)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(if data is accessed sequentially. A value of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(0)"} /* inline code */,
    {{} /* set() */, R"( completely disables)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(detection and prefetching.)"} /* raw text */,
}};

constexpr uint32_t const line85_indent_first{0};
constexpr uint32_t const line85_indent_next{0};
constexpr std::array<element, 0> const line85_elements{{
}};

// paragraph
constexpr uint32_t const line86_indent_first{8};
constexpr uint32_t const line86_indent_next{8};
constexpr std::array<element, 6> const line86_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o perfmon=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(name)"} /* raw text */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(+)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(name)"} /* raw text */,
    {{} /* set() */, R"(...])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line87_indent_first{16};
constexpr uint32_t const line87_indent_next{16};
constexpr std::array<element, 16> const line87_elements{{
    {{} /* set() */, R"(Enable performance monitoring for the list of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(+)"} /* inline code */,
    {{} /* set() */, R"(-separated components.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(This option is only available if the project was built with performance)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(monitoring enabled. Available components include )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fuse)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(filesystem_v2)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(inode_reader_v2)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(block_cache)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line88_indent_first{0};
constexpr uint32_t const line88_indent_next{0};
constexpr std::array<element, 0> const line88_elements{{
}};

// paragraph
constexpr uint32_t const line89_indent_first{8};
constexpr uint32_t const line89_indent_next{8};
constexpr std::array<element, 3> const line89_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o perfmon_trace=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line90_indent_first{16};
constexpr uint32_t const line90_indent_next{16};
constexpr std::array<element, 5> const line90_elements{{
    {{} /* set() */, R"(Write JSON trace data for all components enabled by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--perfmon)"} /* inline code */,
    {{} /* set() */, R"( to this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file when the process exits.)"} /* raw text */,
}};

constexpr uint32_t const line91_indent_first{0};
constexpr uint32_t const line91_indent_next{0};
constexpr std::array<element, 0> const line91_elements{{
}};

// paragraph
constexpr uint32_t const line92_indent_first{8};
constexpr uint32_t const line92_indent_next{16};
constexpr std::array<element, 11> const line92_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--man)"} /* inline code */,
    {{} /* set() */, R"(   )"} /* raw text */,
    {{} /* set() */, R"(If the project was built with support for built-in manual pages, this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(option will show the manual page. If supported by the terminal and a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(suitable pager (e.g. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(less)"} /* inline code */,
    {{} /* set() */, R"() is found, the manual page is displayed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in the pager.)"} /* raw text */,
}};

constexpr uint32_t const line93_indent_first{0};
constexpr uint32_t const line93_indent_next{0};
constexpr std::array<element, 0> const line93_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc1909474d0>
#endif
// paragraph
constexpr uint32_t const line94_indent_first{8};
constexpr uint32_t const line94_indent_next{8};
constexpr std::array<element, 7> const line94_elements{{
    {{} /* set() */, R"(There's two particular FUSE options that you'll likely need at some)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(point, e.g. when trying to set up an )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(overlayfs)"} /* inline code */,
    {{} /* set() */, R"( mount on top of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(a DwarFS image:)"} /* raw text */,
}};

constexpr uint32_t const line95_indent_first{0};
constexpr uint32_t const line95_indent_next{0};
constexpr std::array<element, 0> const line95_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7fc190944ef0>], list item)]
#endif
// paragraph
constexpr uint32_t const line96_indent_first{8};
constexpr uint32_t const line96_indent_next{8};
constexpr std::array<element, 4> const line96_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o allow_root)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o allow_other)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line97_indent_first{16};
constexpr uint32_t const line97_indent_next{16};
constexpr std::array<element, 29> const line97_elements{{
    {{} /* set() */, R"(These will ensure that the mounted file system can be read by)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(either )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(root)"} /* inline code */,
    {{} /* set() */, R"( or any other user in addition to the user that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(started the fuse driver. So if you're running )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( as a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(non-privileged user, you want to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o allow_root)"} /* inline code */,
    {{} /* set() */, R"( in case )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(root)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(needs access, for example when you're trying to use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(overlayfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(along with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"(. If you're running )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(root)"} /* inline code */,
    {{} /* set() */, R"(, you)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(need )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(allow_other)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line98_indent_first{0};
constexpr uint32_t const line98_indent_next{0};
constexpr std::array<element, 0> const line98_elements{{
}};

#if 0
Heading(2, ENVIRONMENT VARIABLES, None)
#endif
constexpr uint32_t const line99_indent_first{0};
constexpr uint32_t const line99_indent_next{0};
constexpr std::array<element, 1> const line99_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(ENVIRONMENT VARIABLES)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190947c50>
#endif
// paragraph
constexpr uint32_t const line100_indent_first{8};
constexpr uint32_t const line100_indent_next{8};
constexpr std::array<element, 7> const line100_elements{{
    {{} /* set() */, R"(See )"} /* raw text */,
    {{} /* set() */, R"(dwarfs-env(7))"} /* raw text */,
    {{} /* set() */, R"( for environment variables that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(influence the behavior of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line101_indent_first{0};
constexpr uint32_t const line101_indent_next{0};
constexpr std::array<element, 0> const line101_elements{{
}};

#if 0
Heading(2, TIPS & TRICKS, None)
#endif
constexpr uint32_t const line102_indent_first{0};
constexpr uint32_t const line102_indent_next{0};
constexpr std::array<element, 1> const line102_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(TIPS & TRICKS)"} /* raw text */,
}};

#if 0
Heading(3, Adding a DwarFS image to /etc/fstab, None)
#endif
constexpr uint32_t const line103_indent_first{4};
constexpr uint32_t const line103_indent_next{4};
constexpr std::array<element, 1> const line103_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'head', 'h3'} */, R"(Adding a DwarFS image to /etc/fstab)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190947dd0>
#endif
// paragraph
constexpr uint32_t const line104_indent_first{8};
constexpr uint32_t const line104_indent_next{8};
constexpr std::array<element, 7> const line104_elements{{
    {{} /* set() */, R"(This should be relatively straightforward if you're already familiar)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(with adding other FUSE file systems to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/etc/fstab)"} /* inline code */,
    {{} /* set() */, R"(. An entry looks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(like this:)"} /* raw text */,
}};

constexpr uint32_t const line105_indent_first{0};
constexpr uint32_t const line105_indent_next{0};
constexpr std::array<element, 0> const line105_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190c82e90>
#endif
// raw text
constexpr uint32_t const line106_indent_first{12};
constexpr uint32_t const line106_indent_next{12};
constexpr std::array<element, 1> const line106_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs#/path/to/image.dwarfs /mnt/mountpoint fuse noauto,defaults,user,cachesize=1g 0 0)"} /* None */,
}};

// raw text
constexpr uint32_t const line107_indent_first{12};
constexpr uint32_t const line107_indent_next{12};
constexpr std::array<element, 1> const line107_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190945370>
#endif
// paragraph
constexpr uint32_t const line108_indent_first{8};
constexpr uint32_t const line108_indent_next{8};
constexpr std::array<element, 23> const line108_elements{{
    {{} /* set() */, R"(The first bit before the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(#)"} /* inline code */,
    {{} /* set() */, R"( tells )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mount)"} /* inline code */,
    {{} /* set() */, R"( to look for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mount.dwarfs)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(which is installed as a symbolic link to the DwarFS FUSE driver. The)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(part after the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(#)"} /* inline code */,
    {{} /* set() */, R"( looks pretty much like any other )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fstab)"} /* inline code */,
    {{} /* set() */, R"( entry.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(It starts with the path of the file system image to mount, followed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(by the mount point, followed by the file system type ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fuse)"} /* inline code */,
    {{} /* set() */, R"(), and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(finally followed by a set of options.)"} /* raw text */,
}};

constexpr uint32_t const line109_indent_first{0};
constexpr uint32_t const line109_indent_next{0};
constexpr std::array<element, 0> const line109_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945c10>
#endif
// paragraph
constexpr uint32_t const line110_indent_first{8};
constexpr uint32_t const line110_indent_next{8};
constexpr std::array<element, 19> const line110_elements{{
    {{} /* set() */, R"(If you want to automatically mount a DwarFS file system, you'll also)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(need the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(allow_other)"} /* inline code */,
    {{} /* set() */, R"( option to make sure non-privileged users will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be able to access the data. If you want to work with overlays, you'll)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(need either )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(allow_other)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(allow_root)"} /* inline code */,
    {{} /* set() */, R"(. For any of these options)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to work, you will have to set )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(user_allow_other)"} /* inline code */,
    {{} /* set() */, R"( in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/etc/fuse.conf)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line111_indent_first{0};
constexpr uint32_t const line111_indent_next{0};
constexpr std::array<element, 0> const line111_elements{{
}};

#if 0
Heading(3, Setting up a writable file system on top of a DwarFS image, None)
#endif
constexpr uint32_t const line112_indent_first{4};
constexpr uint32_t const line112_indent_next{4};
constexpr std::array<element, 1> const line112_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'head', 'h3'} */, R"(Setting up a writable file system on top of a DwarFS image)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190945550>
#endif
// paragraph
constexpr uint32_t const line113_indent_first{8};
constexpr uint32_t const line113_indent_next{8};
constexpr std::array<element, 7> const line113_elements{{
    {{} /* set() */, R"(This will show you how to set up a read/write layer on top of a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(read-only DwarFS image, which can be incredibly handy if you want)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to be able to partially and/or temporarily modify/amend the contents)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of your read-only image.)"} /* raw text */,
}};

constexpr uint32_t const line114_indent_first{0};
constexpr uint32_t const line114_indent_next{0};
constexpr std::array<element, 0> const line114_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945b50>
#endif
// paragraph
constexpr uint32_t const line115_indent_first{8};
constexpr uint32_t const line115_indent_next{8};
constexpr std::array<element, 11> const line115_elements{{
    {{} /* set() */, R"(My primary use case for this feature is keeping over 1000 Perl)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(versions in the DwarFS image and then setting up a read/write)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(layer to be able to install additional modules for each of these)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(versions. When I didn't need the modules anymore, I could just)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(completely wipe the read/write layer and get my pristine original)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(set of Perl versions back.)"} /* raw text */,
}};

constexpr uint32_t const line116_indent_first{0};
constexpr uint32_t const line116_indent_next{0};
constexpr std::array<element, 0> const line116_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945550>
#endif
// paragraph
constexpr uint32_t const line117_indent_first{8};
constexpr uint32_t const line117_indent_next{8};
constexpr std::array<element, 1> const line117_elements{{
    {{} /* set() */, R"(Here's what you need to do:)"} /* raw text */,
}};

constexpr uint32_t const line118_indent_first{0};
constexpr uint32_t const line118_indent_next{0};
constexpr std::array<element, 0> const line118_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7fc190945970>, <__main__.BlockCode object at 0x7fc190c82e90>], list item), ListItem([<__main__.Paragraph object at 0x7fc1909440b0>, <__main__.BlockCode object at 0x7fc190b79f30>], list item), ListItem([<__main__.Paragraph object at 0x7fc190944110>, <__main__.BlockCode object at 0x7fc190b7a060>], list item), ListItem([<__main__.Paragraph object at 0x7fc1909451f0>], list item)]
#endif
// paragraph
constexpr uint32_t const line119_indent_first{8};
constexpr uint32_t const line119_indent_next{8};
constexpr std::array<element, 5> const line119_elements{{
    {{} /* set() */, R"(Create a set of directories. In my case, these are all located)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/tmp/perl)"} /* inline code */,
    {{} /* set() */, R"( as this was the original install location.)"} /* raw text */,
}};

constexpr uint32_t const line120_indent_first{0};
constexpr uint32_t const line120_indent_next{0};
constexpr std::array<element, 0> const line120_elements{{
}};

// raw text
constexpr uint32_t const line121_indent_first{12};
constexpr uint32_t const line121_indent_next{12};
constexpr std::array<element, 1> const line121_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(cd /tmp/perl)"} /* None */,
}};

// raw text
constexpr uint32_t const line122_indent_first{12};
constexpr uint32_t const line122_indent_next{12};
constexpr std::array<element, 1> const line122_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(mkdir install-ro)"} /* None */,
}};

// raw text
constexpr uint32_t const line123_indent_first{12};
constexpr uint32_t const line123_indent_next{12};
constexpr std::array<element, 1> const line123_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(mkdir install-rw)"} /* None */,
}};

// raw text
constexpr uint32_t const line124_indent_first{12};
constexpr uint32_t const line124_indent_next{12};
constexpr std::array<element, 1> const line124_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(mkdir install-work)"} /* None */,
}};

// raw text
constexpr uint32_t const line125_indent_first{12};
constexpr uint32_t const line125_indent_next{12};
constexpr std::array<element, 1> const line125_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(mkdir install)"} /* None */,
}};

// raw text
constexpr uint32_t const line126_indent_first{12};
constexpr uint32_t const line126_indent_next{12};
constexpr std::array<element, 1> const line126_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

// paragraph
constexpr uint32_t const line127_indent_first{8};
constexpr uint32_t const line127_indent_next{8};
constexpr std::array<element, 15> const line127_elements{{
    {{} /* set() */, R"(Mount the DwarFS image. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o allow_root)"} /* inline code */,
    {{} /* set() */, R"( is needed to make sure)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(overlayfs)"} /* inline code */,
    {{} /* set() */, R"( has access to the mounted file system. In order)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o allow_root)"} /* inline code */,
    {{} /* set() */, R"(, you may have to uncomment or add)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(user_allow_other)"} /* inline code */,
    {{} /* set() */, R"( in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/etc/fuse.conf)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line128_indent_first{0};
constexpr uint32_t const line128_indent_next{0};
constexpr std::array<element, 0> const line128_elements{{
}};

// raw text
constexpr uint32_t const line129_indent_first{12};
constexpr uint32_t const line129_indent_next{12};
constexpr std::array<element, 1> const line129_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs perl-install.dwarfs install-ro -o allow_root)"} /* None */,
}};

// raw text
constexpr uint32_t const line130_indent_first{12};
constexpr uint32_t const line130_indent_next{12};
constexpr std::array<element, 1> const line130_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

// paragraph
constexpr uint32_t const line131_indent_first{8};
constexpr uint32_t const line131_indent_next{8};
constexpr std::array<element, 3> const line131_elements{{
    {{} /* set() */, R"(Now set up )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(overlayfs)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line132_indent_first{0};
constexpr uint32_t const line132_indent_next{0};
constexpr std::array<element, 0> const line132_elements{{
}};

// raw text
constexpr uint32_t const line133_indent_first{12};
constexpr uint32_t const line133_indent_next{12};
constexpr std::array<element, 1> const line133_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(sudo mount -t overlay overlay -o lowerdir=install-ro,upperdir=install-rw,workdir=install-work install)"} /* None */,
}};

// raw text
constexpr uint32_t const line134_indent_first{12};
constexpr uint32_t const line134_indent_next{12};
constexpr std::array<element, 1> const line134_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

// paragraph
constexpr uint32_t const line135_indent_first{8};
constexpr uint32_t const line135_indent_next{8};
constexpr std::array<element, 5> const line135_elements{{
    {{} /* set() */, R"(That's it. You should now be able to access a writeable version)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of your DwarFS image in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(install)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line136_indent_first{0};
constexpr uint32_t const line136_indent_next{0};
constexpr std::array<element, 0> const line136_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190944770>
#endif
// paragraph
constexpr uint32_t const line137_indent_first{8};
constexpr uint32_t const line137_indent_next{8};
constexpr std::array<element, 16> const line137_elements{{
    {{} /* set() */, R"(You can go even further than that. Say you have different sets of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(modules that you regularly want to layer on top of the base DwarFS)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(image. In that case, you can simply build a new DwarFS image from)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the read-write directory after unmounting the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(overlayfs)"} /* inline code */,
    {{} /* set() */, R"(, and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(selectively add this by passing a colon-separated list to the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(lowerdir)"} /* inline code */,
    {{} /* set() */, R"( option when setting up the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(overlayfs)"} /* inline code */,
    {{} /* set() */, R"( mount:)"} /* raw text */,
}};

constexpr uint32_t const line138_indent_first{0};
constexpr uint32_t const line138_indent_next{0};
constexpr std::array<element, 0> const line138_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190ca9490>
#endif
// raw text
constexpr uint32_t const line139_indent_first{12};
constexpr uint32_t const line139_indent_next{12};
constexpr std::array<element, 1> const line139_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(sudo mount -t overlay overlay -o lowerdir=install-ro:install-modules install)"} /* None */,
}};

// raw text
constexpr uint32_t const line140_indent_first{12};
constexpr uint32_t const line140_indent_next{12};
constexpr std::array<element, 1> const line140_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944470>
#endif
// paragraph
constexpr uint32_t const line141_indent_first{8};
constexpr uint32_t const line141_indent_next{8};
constexpr std::array<element, 8> const line141_elements{{
    {{} /* set() */, R"(If you want )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(this)"} /* raw text */,
    {{} /* set() */, R"( merged overlay to be writable, just add in the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(upperdir)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(workdir)"} /* inline code */,
    {{} /* set() */, R"( options from before again.)"} /* raw text */,
}};

constexpr uint32_t const line142_indent_first{0};
constexpr uint32_t const line142_indent_next{0};
constexpr std::array<element, 0> const line142_elements{{
}};

#if 0
Heading(3, Optimizing Performance and Memory Usage, None)
#endif
constexpr uint32_t const line143_indent_first{4};
constexpr uint32_t const line143_indent_next{4};
constexpr std::array<element, 1> const line143_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'head', 'h3'} */, R"(Optimizing Performance and Memory Usage)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc1909444d0>
#endif
// paragraph
constexpr uint32_t const line144_indent_first{8};
constexpr uint32_t const line144_indent_next{8};
constexpr std::array<element, 9> const line144_elements{{
    {{} /* set() */, R"(Depending on your use case, you may want to ensure that )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( isn't)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(constantly consuming large amounts of memory. Or you may want to make)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(sure the file system can always be accessed as quickly as possible.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(There are several options to tune performance based on your use case.)"} /* raw text */,
}};

constexpr uint32_t const line145_indent_first{0};
constexpr uint32_t const line145_indent_next{0};
constexpr std::array<element, 0> const line145_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190944590>
#endif
// paragraph
constexpr uint32_t const line146_indent_first{8};
constexpr uint32_t const line146_indent_next{8};
constexpr std::array<element, 7> const line146_elements{{
    {{} /* set() */, R"(If you don't care much about memory, use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(cachesize)"} /* inline code */,
    {{} /* set() */, R"( option to make)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(sure as many decompressed file system blocks as possible can be kept in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(memory.)"} /* raw text */,
}};

constexpr uint32_t const line147_indent_first{0};
constexpr uint32_t const line147_indent_next{0};
constexpr std::array<element, 0> const line147_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190944ef0>
#endif
// paragraph
constexpr uint32_t const line148_indent_first{8};
constexpr uint32_t const line148_indent_next{8};
constexpr std::array<element, 4> const line148_elements{{
    {{} /* set() */, R"(If your file system image is relatively small, you can also use the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(preload_all)"} /* inline code */,
    {{} /* set() */, R"( option to immediately populate the cache after mounting.)"} /* raw text */,
}};

constexpr uint32_t const line149_indent_first{0};
constexpr uint32_t const line149_indent_next{0};
constexpr std::array<element, 0> const line149_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945af0>
#endif
// paragraph
constexpr uint32_t const line150_indent_first{8};
constexpr uint32_t const line150_indent_next{8};
constexpr std::array<element, 25> const line150_elements{{
    {{} /* set() */, R"(The more interesting use case is if you want to be conservative about)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(memory, but still don't want to sacrifice performance too much. Maybe)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you only need to access a lot of files directly after mounting and then)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(only infrequently need to access other files. If this is the case, you)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(can use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_strategy)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_interval)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(tidy_max_age)"} /* inline code */,
    {{} /* set() */, R"( options.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(With these options, you can usually keep the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(cachesize)"} /* inline code */,
    {{} /* set() */, R"( relatively large)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in order to maintain good throughput when accessing files, but the cache)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be tidied up quickly, releasing the memory again if it is no longer)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(accessed. A useful configuration could look like this:)"} /* raw text */,
}};

constexpr uint32_t const line151_indent_first{0};
constexpr uint32_t const line151_indent_next{0};
constexpr std::array<element, 0> const line151_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190b0c490>
#endif
// raw text
constexpr uint32_t const line152_indent_first{12};
constexpr uint32_t const line152_indent_next{12};
constexpr std::array<element, 1> const line152_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs image mountpoint -otidy_strategy=time,tidy_interval=5s,tidy_max_age=10s)"} /* None */,
}};

// raw text
constexpr uint32_t const line153_indent_first{12};
constexpr uint32_t const line153_indent_next{12};
constexpr std::array<element, 1> const line153_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc1909443b0>
#endif
// paragraph
constexpr uint32_t const line154_indent_first{8};
constexpr uint32_t const line154_indent_next{8};
constexpr std::array<element, 12> const line154_elements{{
    {{} /* set() */, R"(This will check the cache every 5 seconds and evict any blocks from the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(cache that haven't been accessed for more than 10 seconds. What sounds)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(good in theory can be tricky in practice: just because )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( has freed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the memory doesn't necessarily mean that the memory allocator will )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(really)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(return the memory to the system.)"} /* raw text */,
}};

constexpr uint32_t const line155_indent_first{0};
constexpr uint32_t const line155_indent_next{0};
constexpr std::array<element, 0> const line155_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945a30>
#endif
// paragraph
constexpr uint32_t const line156_indent_first{8};
constexpr uint32_t const line156_indent_next{8};
constexpr std::array<element, 10> const line156_elements{{
    {{} /* set() */, R"(If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( is built with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(jemalloc)"} /* inline code */,
    {{} /* set() */, R"(, the memory allocator can be tuned)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to return memory to the system quickly by setting the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(MALLOC_CONF)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(environment variable, for example:)"} /* raw text */,
}};

constexpr uint32_t const line157_indent_first{0};
constexpr uint32_t const line157_indent_next{0};
constexpr std::array<element, 0> const line157_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190b0c490>
#endif
// raw text
constexpr uint32_t const line158_indent_first{12};
constexpr uint32_t const line158_indent_next{12};
constexpr std::array<element, 1> const line158_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(MALLOC_CONF="background_thread:true,dirty_decay_ms:5000,muzzy_decay_ms:5000")"} /* None */,
}};

// raw text
constexpr uint32_t const line159_indent_first{12};
constexpr uint32_t const line159_indent_next{12};
constexpr std::array<element, 1> const line159_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944590>
#endif
// paragraph
constexpr uint32_t const line160_indent_first{8};
constexpr uint32_t const line160_indent_next{8};
constexpr std::array<element, 13> const line160_elements{{
    {{} /* set() */, R"(If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( is )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(not)"} /* raw text */,
    {{} /* set() */, R"( build with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(jemalloc)"} /* inline code */,
    {{} /* set() */, R"(, it is still possible to run it)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(jemalloc)"} /* inline code */,
    {{} /* set() */, R"( by using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(LD_PRELOAD)"} /* inline code */,
    {{} /* set() */, R"(:)"} /* raw text */,
}};

constexpr uint32_t const line161_indent_first{0};
constexpr uint32_t const line161_indent_next{0};
constexpr std::array<element, 0> const line161_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190cbce50>
#endif
// raw text
constexpr uint32_t const line162_indent_first{12};
constexpr uint32_t const line162_indent_next{12};
constexpr std::array<element, 1> const line162_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(LD_PRELOAD=/usr/lib/libjemalloc.so dwarfs image mountpoint ...)"} /* None */,
}};

// raw text
constexpr uint32_t const line163_indent_first{12};
constexpr uint32_t const line163_indent_next{12};
constexpr std::array<element, 1> const line163_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944530>
#endif
// paragraph
constexpr uint32_t const line164_indent_first{8};
constexpr uint32_t const line164_indent_next{8};
constexpr std::array<element, 13> const line164_elements{{
    {{} /* set() */, R"(The exact location of the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(jemalloc)"} /* inline code */,
    {{} /* set() */, R"( shared object depends on your system.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If that is )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(also)"} /* raw text */,
    {{} /* set() */, R"( not an option, you can use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(block_allocator)"} /* inline code */,
    {{} /* set() */, R"( option)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"(:)"} /* raw text */,
}};

constexpr uint32_t const line165_indent_first{0};
constexpr uint32_t const line165_indent_next{0};
constexpr std::array<element, 0> const line165_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190cbce50>
#endif
// raw text
constexpr uint32_t const line166_indent_first{12};
constexpr uint32_t const line166_indent_next{12};
constexpr std::array<element, 1> const line166_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs image mountpoint -oblock_allocator=mmap,tidy_strategy=time,...)"} /* None */,
}};

// raw text
constexpr uint32_t const line167_indent_first{12};
constexpr uint32_t const line167_indent_next{12};
constexpr std::array<element, 1> const line167_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc1909443b0>
#endif
// paragraph
constexpr uint32_t const line168_indent_first{8};
constexpr uint32_t const line168_indent_next{8};
constexpr std::array<element, 13> const line168_elements{{
    {{} /* set() */, R"(This will instruct )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( to )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(not)"} /* raw text */,
    {{} /* set() */, R"( use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(malloc)"} /* inline code */,
    {{} /* set() */, R"( for allocating blocks,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(but rather use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mmap)"} /* inline code */,
    {{} /* set() */, R"(. This should work nicely, albeit with some potential)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(impact on performance, especially with smaller block sizes.)"} /* raw text */,
}};

constexpr uint32_t const line169_indent_first{0};
constexpr uint32_t const line169_indent_next{0};
constexpr std::array<element, 0> const line169_elements{{
}};

#if 0
Heading(3, Optimizing Application Startup Time, None)
#endif
constexpr uint32_t const line170_indent_first{4};
constexpr uint32_t const line170_indent_next{4};
constexpr std::array<element, 1> const line170_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'head', 'h3'} */, R"(Optimizing Application Startup Time)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944590>
#endif
// paragraph
constexpr uint32_t const line171_indent_first{8};
constexpr uint32_t const line171_indent_next{8};
constexpr std::array<element, 3> const line171_elements{{
    {{} /* set() */, R"(If you're using DwarFS as storage for an application container, you may)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(want to optimize startup time. There are different ways to do that.)"} /* raw text */,
}};

constexpr uint32_t const line172_indent_first{0};
constexpr uint32_t const line172_indent_next{0};
constexpr std::array<element, 0> const line172_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945af0>
#endif
// paragraph
constexpr uint32_t const line173_indent_first{8};
constexpr uint32_t const line173_indent_next{8};
constexpr std::array<element, 11> const line173_elements{{
    {{} /* set() */, R"(If the application is going to read most of the file system image data)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(during startup, and the image is relatively small, it's worth trying to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(just use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(preload_all)"} /* inline code */,
    {{} /* set() */, R"( option. This will fill the cache with blocks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(from the file system image as soon as it is mounted and can already have)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(a significant impact on startup time.)"} /* raw text */,
}};

constexpr uint32_t const line174_indent_first{0};
constexpr uint32_t const line174_indent_next{0};
constexpr std::array<element, 0> const line174_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190944650>
#endif
// paragraph
constexpr uint32_t const line175_indent_first{8};
constexpr uint32_t const line175_indent_next{8};
constexpr std::array<element, 7> const line175_elements{{
    {{} /* set() */, R"(If the application is only using a small subset of the data in the image)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(during startup, you can use "hotness" analysis and build an image that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is optimized to improve startup speed. It's basically profile guide)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(optimization for file systems.)"} /* raw text */,
}};

constexpr uint32_t const line176_indent_first{0};
constexpr uint32_t const line176_indent_next{0};
constexpr std::array<element, 0> const line176_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc1909457f0>
#endif
// paragraph
constexpr uint32_t const line177_indent_first{8};
constexpr uint32_t const line177_indent_next{8};
constexpr std::array<element, 5> const line177_elements{{
    {{} /* set() */, R"(First you have to build an initial image you can use to perform the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(analysis. Then, you use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(analysis_file)"} /* inline code */,
    {{} /* set() */, R"( option to mount the image:)"} /* raw text */,
}};

constexpr uint32_t const line178_indent_first{0};
constexpr uint32_t const line178_indent_next{0};
constexpr std::array<element, 0> const line178_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190cba120>
#endif
// raw text
constexpr uint32_t const line179_indent_first{12};
constexpr uint32_t const line179_indent_next{12};
constexpr std::array<element, 1> const line179_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs image mountpoint -oanalysis_file=/tmp/image.prof)"} /* None */,
}};

// raw text
constexpr uint32_t const line180_indent_first{12};
constexpr uint32_t const line180_indent_next{12};
constexpr std::array<element, 1> const line180_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944530>
#endif
// paragraph
constexpr uint32_t const line181_indent_first{8};
constexpr uint32_t const line181_indent_next{8};
constexpr std::array<element, 9> const line181_elements{{
    {{} /* set() */, R"(While the image is mounted, you start the application (or perform)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(whichever task you want to optimize the file system for). Then, when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you unmount the image, the file you have specified will contain a list)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of all paths in the image that have been accessed, in the order in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(which the access happened.)"} /* raw text */,
}};

constexpr uint32_t const line182_indent_first{0};
constexpr uint32_t const line182_indent_next{0};
constexpr std::array<element, 0> const line182_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945b50>
#endif
// paragraph
constexpr uint32_t const line183_indent_first{8};
constexpr uint32_t const line183_indent_next{8};
constexpr std::array<element, 9> const line183_elements{{
    {{} /* set() */, R"(You can then use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hotness)"} /* inline code */,
    {{} /* set() */, R"( categorizer in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"(, potentially)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(along with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(explicit)"} /* inline code */,
    {{} /* set() */, R"( ordering, to build the optimized image:)"} /* raw text */,
}};

constexpr uint32_t const line184_indent_first{0};
constexpr uint32_t const line184_indent_next{0};
constexpr std::array<element, 0> const line184_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190cba120>
#endif
// raw text
constexpr uint32_t const line185_indent_first{12};
constexpr uint32_t const line185_indent_next{12};
constexpr std::array<element, 1> const line185_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(mkdwarfs -i input -o image --categorize=hotness --hotness-list=/tmp/image.prof)"} /* None */,
}};

// raw text
constexpr uint32_t const line186_indent_first{12};
constexpr uint32_t const line186_indent_next{12};
constexpr std::array<element, 1> const line186_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190945b50>
#endif
// paragraph
constexpr uint32_t const line187_indent_first{8};
constexpr uint32_t const line187_indent_next{8};
constexpr std::array<element, 1> const line187_elements{{
    {{} /* set() */, R"(Or, with additional explicit ordering:)"} /* raw text */,
}};

constexpr uint32_t const line188_indent_first{0};
constexpr uint32_t const line188_indent_next{0};
constexpr std::array<element, 0> const line188_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190951550>
#endif
// raw text
constexpr uint32_t const line189_indent_first{12};
constexpr uint32_t const line189_indent_next{12};
constexpr std::array<element, 1> const line189_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(mkdwarfs -i input -o image --categorize=hotness --hotness-list=/tmp/image.prof \)"} /* None */,
}};

// raw text
constexpr uint32_t const line190_indent_first{12};
constexpr uint32_t const line190_indent_next{12};
constexpr std::array<element, 1> const line190_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(         --order hotness::explicit:file=/tmp/image.prof)"} /* None */,
}};

// raw text
constexpr uint32_t const line191_indent_first{12};
constexpr uint32_t const line191_indent_next{12};
constexpr std::array<element, 1> const line191_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190945910>
#endif
// paragraph
constexpr uint32_t const line192_indent_first{8};
constexpr uint32_t const line192_indent_next{8};
constexpr std::array<element, 5> const line192_elements{{
    {{} /* set() */, R"(This will order the files in the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hotness)"} /* inline code */,
    {{} /* set() */, R"( category using the same order)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as in the profile. Otherwise, they will be ordered by similarity.)"} /* raw text */,
}};

constexpr uint32_t const line193_indent_first{0};
constexpr uint32_t const line193_indent_next{0};
constexpr std::array<element, 0> const line193_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190945a30>
#endif
// paragraph
constexpr uint32_t const line194_indent_first{8};
constexpr uint32_t const line194_indent_next{8};
constexpr std::array<element, 4> const line194_elements{{
    {{} /* set() */, R"(Once you have built this optimized image, you can mount it using the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(preload_category)"} /* inline code */,
    {{} /* set() */, R"( option:)"} /* raw text */,
}};

constexpr uint32_t const line195_indent_first{0};
constexpr uint32_t const line195_indent_next{0};
constexpr std::array<element, 0> const line195_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7fc190950830>
#endif
// raw text
constexpr uint32_t const line196_indent_first{12};
constexpr uint32_t const line196_indent_next{12};
constexpr std::array<element, 1> const line196_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(dwarfs image mountpoint -opreload_category=hotness)"} /* None */,
}};

// raw text
constexpr uint32_t const line197_indent_first{12};
constexpr uint32_t const line197_indent_next{12};
constexpr std::array<element, 1> const line197_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"()"} /* None */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190945b50>
#endif
// paragraph
constexpr uint32_t const line198_indent_first{8};
constexpr uint32_t const line198_indent_next{8};
constexpr std::array<element, 5> const line198_elements{{
    {{} /* set() */, R"(This will preload all )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hotness)"} /* inline code */,
    {{} /* set() */, R"( blocks into the cache immediately after)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(mounting and hopefully speed up application startup significantly.)"} /* raw text */,
}};

constexpr uint32_t const line199_indent_first{0};
constexpr uint32_t const line199_indent_next{0};
constexpr std::array<element, 0> const line199_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7fc190944770>
#endif
// paragraph
constexpr uint32_t const line200_indent_first{8};
constexpr uint32_t const line200_indent_next{8};
constexpr std::array<element, 23> const line200_elements{{
    {{} /* set() */, R"(There are plenty of other ways you can tune how the image is generated.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(For example, if the input data already contains compressed files, you)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(may want to add the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"( categorizer. This will not only)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(speed up the creation of the file system image as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( won't waste)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(time trying to compress incompressible data, but also speed up access as)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the data won't need to be decompressed. Also, you could think about using)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(different compression algorithms for the "hot" and "cold" files, e.g.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(something fast like )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(zstd)"} /* inline code */,
    {{} /* set() */, R"( for the hot files and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(lzma)"} /* inline code */,
    {{} /* set() */, R"( for the cold files.)"} /* raw text */,
}};

constexpr uint32_t const line201_indent_first{0};
constexpr uint32_t const line201_indent_next{0};
constexpr std::array<element, 0> const line201_elements{{
}};

#if 0
Heading(2, AUTHOR, None)
#endif
constexpr uint32_t const line202_indent_first{0};
constexpr uint32_t const line202_indent_next{0};
constexpr std::array<element, 1> const line202_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(AUTHOR)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944770>
#endif
// paragraph
constexpr uint32_t const line203_indent_first{8};
constexpr uint32_t const line203_indent_next{8};
constexpr std::array<element, 1> const line203_elements{{
    {{} /* set() */, R"(Written by Marcus Holland-Moritz.)"} /* raw text */,
}};

constexpr uint32_t const line204_indent_first{0};
constexpr uint32_t const line204_indent_next{0};
constexpr std::array<element, 0> const line204_elements{{
}};

#if 0
Heading(2, COPYRIGHT, None)
#endif
constexpr uint32_t const line205_indent_first{0};
constexpr uint32_t const line205_indent_next{0};
constexpr std::array<element, 1> const line205_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(COPYRIGHT)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944770>
#endif
// paragraph
constexpr uint32_t const line206_indent_first{8};
constexpr uint32_t const line206_indent_next{8};
constexpr std::array<element, 1> const line206_elements{{
    {{} /* set() */, R"(Copyright (C) Marcus Holland-Moritz.)"} /* raw text */,
}};

constexpr uint32_t const line207_indent_first{0};
constexpr uint32_t const line207_indent_next{0};
constexpr std::array<element, 0> const line207_elements{{
}};

#if 0
Heading(2, SEE ALSO, None)
#endif
constexpr uint32_t const line208_indent_first{0};
constexpr uint32_t const line208_indent_next{0};
constexpr std::array<element, 1> const line208_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h2', 'head'} */, R"(SEE ALSO)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7fc190944410>
#endif
// paragraph
constexpr uint32_t const line209_indent_first{8};
constexpr uint32_t const line209_indent_next{8};
constexpr std::array<element, 9> const line209_elements{{
    {{} /* set() */, R"(mkdwarfs(1))"} /* raw text */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {{} /* set() */, R"(dwarfsextract(1))"} /* raw text */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {{} /* set() */, R"(dwarfsck(1))"} /* raw text */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {{} /* set() */, R"(dwarfs-format(5))"} /* raw text */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {{} /* set() */, R"(dwarfs-env(7))"} /* raw text */,
}};

constexpr uint32_t const line210_indent_first{0};
constexpr uint32_t const line210_indent_next{0};
constexpr std::array<element, 0> const line210_elements{{
}};

constexpr std::array<line, 211> const document_array{{
    {line0_indent_first, line0_indent_next, line0_elements},
    {line1_indent_first, line1_indent_next, line1_elements},
    {line2_indent_first, line2_indent_next, line2_elements},
    {line3_indent_first, line3_indent_next, line3_elements},
    {line4_indent_first, line4_indent_next, line4_elements},
    {line5_indent_first, line5_indent_next, line5_elements},
    {line6_indent_first, line6_indent_next, line6_elements},
    {line7_indent_first, line7_indent_next, line7_elements},
    {line8_indent_first, line8_indent_next, line8_elements},
    {line9_indent_first, line9_indent_next, line9_elements},
    {line10_indent_first, line10_indent_next, line10_elements},
    {line11_indent_first, line11_indent_next, line11_elements},
    {line12_indent_first, line12_indent_next, line12_elements},
    {line13_indent_first, line13_indent_next, line13_elements},
    {line14_indent_first, line14_indent_next, line14_elements},
    {line15_indent_first, line15_indent_next, line15_elements},
    {line16_indent_first, line16_indent_next, line16_elements},
    {line17_indent_first, line17_indent_next, line17_elements},
    {line18_indent_first, line18_indent_next, line18_elements},
    {line19_indent_first, line19_indent_next, line19_elements},
    {line20_indent_first, line20_indent_next, line20_elements},
    {line21_indent_first, line21_indent_next, line21_elements},
    {line22_indent_first, line22_indent_next, line22_elements},
    {line23_indent_first, line23_indent_next, line23_elements},
    {line24_indent_first, line24_indent_next, line24_elements},
    {line25_indent_first, line25_indent_next, line25_elements},
    {line26_indent_first, line26_indent_next, line26_elements},
    {line27_indent_first, line27_indent_next, line27_elements},
    {line28_indent_first, line28_indent_next, line28_elements},
    {line29_indent_first, line29_indent_next, line29_elements},
    {line30_indent_first, line30_indent_next, line30_elements},
    {line31_indent_first, line31_indent_next, line31_elements},
    {line32_indent_first, line32_indent_next, line32_elements},
    {line33_indent_first, line33_indent_next, line33_elements},
    {line34_indent_first, line34_indent_next, line34_elements},
    {line35_indent_first, line35_indent_next, line35_elements},
    {line36_indent_first, line36_indent_next, line36_elements},
    {line37_indent_first, line37_indent_next, line37_elements},
    {line38_indent_first, line38_indent_next, line38_elements},
    {line39_indent_first, line39_indent_next, line39_elements},
    {line40_indent_first, line40_indent_next, line40_elements},
    {line41_indent_first, line41_indent_next, line41_elements},
    {line42_indent_first, line42_indent_next, line42_elements},
    {line43_indent_first, line43_indent_next, line43_elements},
    {line44_indent_first, line44_indent_next, line44_elements},
    {line45_indent_first, line45_indent_next, line45_elements},
    {line46_indent_first, line46_indent_next, line46_elements},
    {line47_indent_first, line47_indent_next, line47_elements},
    {line48_indent_first, line48_indent_next, line48_elements},
    {line49_indent_first, line49_indent_next, line49_elements},
    {line50_indent_first, line50_indent_next, line50_elements},
    {line51_indent_first, line51_indent_next, line51_elements},
    {line52_indent_first, line52_indent_next, line52_elements},
    {line53_indent_first, line53_indent_next, line53_elements},
    {line54_indent_first, line54_indent_next, line54_elements},
    {line55_indent_first, line55_indent_next, line55_elements},
    {line56_indent_first, line56_indent_next, line56_elements},
    {line57_indent_first, line57_indent_next, line57_elements},
    {line58_indent_first, line58_indent_next, line58_elements},
    {line59_indent_first, line59_indent_next, line59_elements},
    {line60_indent_first, line60_indent_next, line60_elements},
    {line61_indent_first, line61_indent_next, line61_elements},
    {line62_indent_first, line62_indent_next, line62_elements},
    {line63_indent_first, line63_indent_next, line63_elements},
    {line64_indent_first, line64_indent_next, line64_elements},
    {line65_indent_first, line65_indent_next, line65_elements},
    {line66_indent_first, line66_indent_next, line66_elements},
    {line67_indent_first, line67_indent_next, line67_elements},
    {line68_indent_first, line68_indent_next, line68_elements},
    {line69_indent_first, line69_indent_next, line69_elements},
    {line70_indent_first, line70_indent_next, line70_elements},
    {line71_indent_first, line71_indent_next, line71_elements},
    {line72_indent_first, line72_indent_next, line72_elements},
    {line73_indent_first, line73_indent_next, line73_elements},
    {line74_indent_first, line74_indent_next, line74_elements},
    {line75_indent_first, line75_indent_next, line75_elements},
    {line76_indent_first, line76_indent_next, line76_elements},
    {line77_indent_first, line77_indent_next, line77_elements},
    {line78_indent_first, line78_indent_next, line78_elements},
    {line79_indent_first, line79_indent_next, line79_elements},
    {line80_indent_first, line80_indent_next, line80_elements},
    {line81_indent_first, line81_indent_next, line81_elements},
    {line82_indent_first, line82_indent_next, line82_elements},
    {line83_indent_first, line83_indent_next, line83_elements},
    {line84_indent_first, line84_indent_next, line84_elements},
    {line85_indent_first, line85_indent_next, line85_elements},
    {line86_indent_first, line86_indent_next, line86_elements},
    {line87_indent_first, line87_indent_next, line87_elements},
    {line88_indent_first, line88_indent_next, line88_elements},
    {line89_indent_first, line89_indent_next, line89_elements},
    {line90_indent_first, line90_indent_next, line90_elements},
    {line91_indent_first, line91_indent_next, line91_elements},
    {line92_indent_first, line92_indent_next, line92_elements},
    {line93_indent_first, line93_indent_next, line93_elements},
    {line94_indent_first, line94_indent_next, line94_elements},
    {line95_indent_first, line95_indent_next, line95_elements},
    {line96_indent_first, line96_indent_next, line96_elements},
    {line97_indent_first, line97_indent_next, line97_elements},
    {line98_indent_first, line98_indent_next, line98_elements},
    {line99_indent_first, line99_indent_next, line99_elements},
    {line100_indent_first, line100_indent_next, line100_elements},
    {line101_indent_first, line101_indent_next, line101_elements},
    {line102_indent_first, line102_indent_next, line102_elements},
    {line103_indent_first, line103_indent_next, line103_elements},
    {line104_indent_first, line104_indent_next, line104_elements},
    {line105_indent_first, line105_indent_next, line105_elements},
    {line106_indent_first, line106_indent_next, line106_elements},
    {line107_indent_first, line107_indent_next, line107_elements},
    {line108_indent_first, line108_indent_next, line108_elements},
    {line109_indent_first, line109_indent_next, line109_elements},
    {line110_indent_first, line110_indent_next, line110_elements},
    {line111_indent_first, line111_indent_next, line111_elements},
    {line112_indent_first, line112_indent_next, line112_elements},
    {line113_indent_first, line113_indent_next, line113_elements},
    {line114_indent_first, line114_indent_next, line114_elements},
    {line115_indent_first, line115_indent_next, line115_elements},
    {line116_indent_first, line116_indent_next, line116_elements},
    {line117_indent_first, line117_indent_next, line117_elements},
    {line118_indent_first, line118_indent_next, line118_elements},
    {line119_indent_first, line119_indent_next, line119_elements},
    {line120_indent_first, line120_indent_next, line120_elements},
    {line121_indent_first, line121_indent_next, line121_elements},
    {line122_indent_first, line122_indent_next, line122_elements},
    {line123_indent_first, line123_indent_next, line123_elements},
    {line124_indent_first, line124_indent_next, line124_elements},
    {line125_indent_first, line125_indent_next, line125_elements},
    {line126_indent_first, line126_indent_next, line126_elements},
    {line127_indent_first, line127_indent_next, line127_elements},
    {line128_indent_first, line128_indent_next, line128_elements},
    {line129_indent_first, line129_indent_next, line129_elements},
    {line130_indent_first, line130_indent_next, line130_elements},
    {line131_indent_first, line131_indent_next, line131_elements},
    {line132_indent_first, line132_indent_next, line132_elements},
    {line133_indent_first, line133_indent_next, line133_elements},
    {line134_indent_first, line134_indent_next, line134_elements},
    {line135_indent_first, line135_indent_next, line135_elements},
    {line136_indent_first, line136_indent_next, line136_elements},
    {line137_indent_first, line137_indent_next, line137_elements},
    {line138_indent_first, line138_indent_next, line138_elements},
    {line139_indent_first, line139_indent_next, line139_elements},
    {line140_indent_first, line140_indent_next, line140_elements},
    {line141_indent_first, line141_indent_next, line141_elements},
    {line142_indent_first, line142_indent_next, line142_elements},
    {line143_indent_first, line143_indent_next, line143_elements},
    {line144_indent_first, line144_indent_next, line144_elements},
    {line145_indent_first, line145_indent_next, line145_elements},
    {line146_indent_first, line146_indent_next, line146_elements},
    {line147_indent_first, line147_indent_next, line147_elements},
    {line148_indent_first, line148_indent_next, line148_elements},
    {line149_indent_first, line149_indent_next, line149_elements},
    {line150_indent_first, line150_indent_next, line150_elements},
    {line151_indent_first, line151_indent_next, line151_elements},
    {line152_indent_first, line152_indent_next, line152_elements},
    {line153_indent_first, line153_indent_next, line153_elements},
    {line154_indent_first, line154_indent_next, line154_elements},
    {line155_indent_first, line155_indent_next, line155_elements},
    {line156_indent_first, line156_indent_next, line156_elements},
    {line157_indent_first, line157_indent_next, line157_elements},
    {line158_indent_first, line158_indent_next, line158_elements},
    {line159_indent_first, line159_indent_next, line159_elements},
    {line160_indent_first, line160_indent_next, line160_elements},
    {line161_indent_first, line161_indent_next, line161_elements},
    {line162_indent_first, line162_indent_next, line162_elements},
    {line163_indent_first, line163_indent_next, line163_elements},
    {line164_indent_first, line164_indent_next, line164_elements},
    {line165_indent_first, line165_indent_next, line165_elements},
    {line166_indent_first, line166_indent_next, line166_elements},
    {line167_indent_first, line167_indent_next, line167_elements},
    {line168_indent_first, line168_indent_next, line168_elements},
    {line169_indent_first, line169_indent_next, line169_elements},
    {line170_indent_first, line170_indent_next, line170_elements},
    {line171_indent_first, line171_indent_next, line171_elements},
    {line172_indent_first, line172_indent_next, line172_elements},
    {line173_indent_first, line173_indent_next, line173_elements},
    {line174_indent_first, line174_indent_next, line174_elements},
    {line175_indent_first, line175_indent_next, line175_elements},
    {line176_indent_first, line176_indent_next, line176_elements},
    {line177_indent_first, line177_indent_next, line177_elements},
    {line178_indent_first, line178_indent_next, line178_elements},
    {line179_indent_first, line179_indent_next, line179_elements},
    {line180_indent_first, line180_indent_next, line180_elements},
    {line181_indent_first, line181_indent_next, line181_elements},
    {line182_indent_first, line182_indent_next, line182_elements},
    {line183_indent_first, line183_indent_next, line183_elements},
    {line184_indent_first, line184_indent_next, line184_elements},
    {line185_indent_first, line185_indent_next, line185_elements},
    {line186_indent_first, line186_indent_next, line186_elements},
    {line187_indent_first, line187_indent_next, line187_elements},
    {line188_indent_first, line188_indent_next, line188_elements},
    {line189_indent_first, line189_indent_next, line189_elements},
    {line190_indent_first, line190_indent_next, line190_elements},
    {line191_indent_first, line191_indent_next, line191_elements},
    {line192_indent_first, line192_indent_next, line192_elements},
    {line193_indent_first, line193_indent_next, line193_elements},
    {line194_indent_first, line194_indent_next, line194_elements},
    {line195_indent_first, line195_indent_next, line195_elements},
    {line196_indent_first, line196_indent_next, line196_elements},
    {line197_indent_first, line197_indent_next, line197_elements},
    {line198_indent_first, line198_indent_next, line198_elements},
    {line199_indent_first, line199_indent_next, line199_elements},
    {line200_indent_first, line200_indent_next, line200_elements},
    {line201_indent_first, line201_indent_next, line201_elements},
    {line202_indent_first, line202_indent_next, line202_elements},
    {line203_indent_first, line203_indent_next, line203_elements},
    {line204_indent_first, line204_indent_next, line204_elements},
    {line205_indent_first, line205_indent_next, line205_elements},
    {line206_indent_first, line206_indent_next, line206_elements},
    {line207_indent_first, line207_indent_next, line207_elements},
    {line208_indent_first, line208_indent_next, line208_elements},
    {line209_indent_first, line209_indent_next, line209_elements},
    {line210_indent_first, line210_indent_next, line210_elements},
}};
} // namespace

// NOLINTEND(readability-*)

document get_dwarfs_manpage() { return document_array; }

} // namespace dwarfs::tool::manpage
