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

namespace dwarfs::tool::manpage {

// NOLINTBEGIN(readability-*)

namespace {
#if 0
Heading(1, mkdwarfs(1) -- create highly compressed read-only file systems, 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"(mkdwarfs(1) -- create highly compressed read-only file systems)"} /* 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 0x7f0c3b981940>
#endif
// paragraph
constexpr uint32_t const line3_indent_first{8};
constexpr uint32_t const line3_indent_next{8};
constexpr std::array<element, 14> const line3_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-i)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(path)"} /* raw text */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* 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, 15> const line4_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input-list=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* set() */, R"( [)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(options)"} /* raw text */,
    {{} /* set() */, R"(...])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line5_indent_first{8};
constexpr uint32_t const line5_indent_next{8};
constexpr std::array<element, 16> const line5_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-i)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress)"} /* inline code */,
    {{} /* set() */, R"( [)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(options)"} /* raw text */,
    {{} /* set() */, R"(...])"} /* raw text */,
}};

constexpr uint32_t const line6_indent_first{0};
constexpr uint32_t const line6_indent_next{0};
constexpr std::array<element, 0> const line6_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3ba82e90>
#endif
// paragraph
constexpr uint32_t const line8_indent_first{8};
constexpr uint32_t const line8_indent_next{8};
constexpr std::array<element, 10> const line8_elements{{
    {fmt::emphasis::bold /* {'b'} */, R"(mkdwarfs)"} /* raw text */,
    {{} /* set() */, R"( allows you to create highly compressed, read-only file systems)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in the DwarFS format. DwarFS is similar to file systems like SquashFS,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(cramfs or CromFS, but it has some distinct features. For more detail,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(see )"} /* raw text */,
    {{} /* set() */, R"(dwarfs(1))"} /* raw text */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line9_indent_first{0};
constexpr uint32_t const line9_indent_next{0};
constexpr std::array<element, 0> const line9_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3ba834d0>
#endif
// paragraph
constexpr uint32_t const line10_indent_first{8};
constexpr uint32_t const line10_indent_next{8};
constexpr std::array<element, 5> const line10_elements{{
    {{} /* set() */, R"(In its simplest usage form, you can create a file system containing the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(full contents of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/path/dir)"} /* inline code */,
    {{} /* set() */, R"( with:)"} /* raw text */,
}};

constexpr uint32_t const line11_indent_first{0};
constexpr uint32_t const line11_indent_next{0};
constexpr std::array<element, 0> const line11_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7f0c3b981940>
#endif
// 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"(mkdwarfs -i /path/dir -o image.dwarfs)"} /* None */,
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b9788a0>
#endif
// paragraph
constexpr uint32_t const line14_indent_first{8};
constexpr uint32_t const line14_indent_next{8};
constexpr std::array<element, 3> const line14_elements{{
    {{} /* set() */, R"(After that, you can mount it using )"} /* raw text */,
    {{} /* set() */, R"(dwarfs(1))"} /* raw text */,
    {{} /* set() */, R"(:)"} /* raw text */,
}};

constexpr uint32_t const line15_indent_first{0};
constexpr uint32_t const line15_indent_next{0};
constexpr std::array<element, 0> const line15_elements{{
}};

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

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

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

#if 0
<__main__.Paragraph object at 0x7f0c3b97a060>
#endif
// paragraph
constexpr uint32_t const line19_indent_first{8};
constexpr uint32_t const line19_indent_next{8};
constexpr std::array<element, 1> const line19_elements{{
    {{} /* set() */, R"(There are two mandatory options for specifying the input and output:)"} /* 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{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7f0c3baa9490>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b90c490>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b90dbf0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3babce50>], list item)]
#endif
// paragraph
constexpr uint32_t const line21_indent_first{8};
constexpr uint32_t const line21_indent_next{8};
constexpr std::array<element, 7> const line21_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-i)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(path)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* 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, 7> const line22_elements{{
    {{} /* set() */, R"(Path to the root directory containing the files from which you want to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(build a file system. If the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress)"} /* inline code */,
    {{} /* set() */, R"( option is given, this argument)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is the source filesystem.)"} /* 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, 5> const line24_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input-list=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* 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, 37> const line25_elements{{
    {{} /* set() */, R"(Read list of file paths to add to the file system from this file or from stdin.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If the paths in the file are relative, they will be interpreted relative to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the path given with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"(. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( is omitted, the path names will be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(interpreted relative to the current directory. If the paths in the file are)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(absolute, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( must be an absolute path that is a prefix to all absolute)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(paths in the file. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( is omitted, the absolute path to the current)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(directory will be used. Any absolute paths in the file for which the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(path is not a prefix will be ignored with an error message. If you want files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to be stored in the exact same order as read from this list (because, for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(example, you have already sorted them by similarity or access frequency), you)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(must also pass )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order=none)"} /* inline code */,
    {{} /* set() */, R"(. This option implicitly enables both)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--with-devices)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--with-specials)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* 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, 7> const line27_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-o)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--output=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* 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, 3> const line28_elements{{
    {{} /* set() */, R"(File name of the output filesystem or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-)"} /* inline code */,
    {{} /* set() */, R"( to write the filesystem to stdout.)"} /* 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, 4> const line30_elements{{
    {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"(--force)"} /* inline code */,
    {{} /* 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, 1> const line31_elements{{
    {{} /* set() */, R"(Force the output file to be overwritten if it already exists.)"} /* 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{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3babd050>
#endif
// paragraph
constexpr uint32_t const line33_indent_first{8};
constexpr uint32_t const line33_indent_next{8};
constexpr std::array<element, 1> const line33_elements{{
    {{} /* set() */, R"(Most other options are concerned with compression tuning:)"} /* raw text */,
}};

constexpr uint32_t const line34_indent_first{0};
constexpr uint32_t const line34_indent_next{0};
constexpr std::array<element, 0> const line34_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7f0c3baba120>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3babb6b0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b9a3770>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b9a51d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3bb24c80>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3ba8d610>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3ba8da90>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b99d860>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b99d7b0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b941ef0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b943b10>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3bbfb920>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b94a450>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b94a650>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3ba2fa80>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3bb5eeb0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7b3170>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c01d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c0b90>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c1130>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c1c10>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c31d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c3590>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7c39b0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7cc530>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7ccb90>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7ce3f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7ceff0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7dd7f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7dde50>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7de330>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7df230>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7df5f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7dffb0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e4530>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e4830>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e4d70>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e5190>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e5490>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e5850>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e5a90>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e5eb0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e60f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e63f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e6ab0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e7170>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7e79b0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f4230>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f44d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f4a10>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f5010>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f5250>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f6030>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f65d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f69f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f6e10>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7110>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7470>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7710>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7a10>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7dd0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7fc350>], list item)]
#endif
// paragraph
constexpr uint32_t const line35_indent_first{8};
constexpr uint32_t const line35_indent_next{8};
constexpr std::array<element, 5> const line35_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-l)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compress-level=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line36_indent_first{16};
constexpr uint32_t const line36_indent_next{16};
constexpr std::array<element, 51> const line36_elements{{
    {{} /* set() */, R"(Compression level to use for the filesystem. )"} /* raw text */,
    {fmt::emphasis::bold /* {'b'} */, R"(If you are unsure, please)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::emphasis::bold /* {'b'} */, R"(stick to the default level of 7.)"} /* raw text */,
    {{} /* set() */, R"( This is intended to provide some)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(sensible defaults and will depend on which compression libraries were)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(available at build time. )"} /* raw text */,
    {fmt::emphasis::bold /* {'b'} */, R"(The default level has been chosen to provide)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::emphasis::bold /* {'b'} */, R"(you with the best possible compression while still keeping the file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::emphasis::bold /* {'b'} */, R"(system very fast to access.)"} /* raw text */,
    {{} /* set() */, R"( Levels 8 and 9 will switch to LZMA)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression (when available), which will likely reduce the file system)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(image size, but will make it about an order of magnitude slower to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(access, so reserve these levels for cases where you only need to access)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the data infrequently. This )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-l)"} /* inline code */,
    {{} /* set() */, R"( option is meant to be the "easy")"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(interface to configure )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"(, and it will actually pick defaults)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for seven distinct options: )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--block-size-bits)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--schema-compression)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--metadata-compression)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-step)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order)"} /* inline code */,
    {{} /* set() */, R"(. See the output of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs -H)"} /* inline code */,
    {{} /* set() */, R"( for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(a table listing the exact defaults used for each compression level.)"} /* raw text */,
}};

constexpr uint32_t const line37_indent_first{0};
constexpr uint32_t const line37_indent_next{0};
constexpr std::array<element, 0> const line37_elements{{
}};

// paragraph
constexpr uint32_t const line38_indent_first{8};
constexpr uint32_t const line38_indent_next{8};
constexpr std::array<element, 7> const line38_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--categorize)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(categorizer)"} /* raw text */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(,)"} /* inline code */,
    {{} /* set() */, R"(...]])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line39_indent_first{16};
constexpr uint32_t const line39_indent_next{16};
constexpr std::array<element, 5> const line39_elements{{
    {{} /* set() */, R"(Enable one or more categorizers in the given order.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(See )"} /* raw text */,
    {{} /* set() */, R"(CATEGORIZERS)"} /* raw text */,
    {{} /* set() */, R"( for more details.)"} /* raw text */,
}};

constexpr uint32_t const line40_indent_first{0};
constexpr uint32_t const line40_indent_next{0};
constexpr std::array<element, 0> const line40_elements{{
}};

// paragraph
constexpr uint32_t const line41_indent_first{8};
constexpr uint32_t const line41_indent_next{8};
constexpr std::array<element, 5> const line41_elements{{
    {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"(--block-size-bits=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line42_indent_first{16};
constexpr uint32_t const line42_indent_next{16};
constexpr std::array<element, 11> const line42_elements{{
    {{} /* set() */, R"(The block size used for the compressed filesystem. The actual block size)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is two to the power of this value. Larger block sizes will offer better)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(overall compression ratios, but will be slower and consume more memory)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(when actually using the filesystem, as blocks will have to be fully or at)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(least partially decompressed into memory. Values between 20 and 26, i.e.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(between 1MiB and 64MiB, usually work quite well.)"} /* raw text */,
}};

constexpr uint32_t const line43_indent_first{0};
constexpr uint32_t const line43_indent_next{0};
constexpr std::array<element, 0> const line43_elements{{
}};

// paragraph
constexpr uint32_t const line44_indent_first{8};
constexpr uint32_t const line44_indent_next{8};
constexpr std::array<element, 5> const line44_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-N)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-workers=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line45_indent_first{16};
constexpr uint32_t const line45_indent_next{16};
constexpr std::array<element, 22> const line45_elements{{
    {{} /* set() */, R"(Number of worker threads used for building the filesystem. This defaults)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to the number of processors available on your system. Use this option if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you want to limit the resources used by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( or to optimize build)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(speed. This option only affects the compression phase directly, but)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(it is also used as a default for both )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-scanner-workers)"} /* inline code */,
    {{} /* set() */, R"( and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-segmenter-workers)"} /* inline code */,
    {{} /* set() */, R"(. During the compression phase, the worker)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(threads are used to compress the individual filesystem blocks in the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(background. Ordering, segmenting and block building are single-threaded)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and run independently for each category.)"} /* raw text */,
}};

constexpr uint32_t const line46_indent_first{0};
constexpr uint32_t const line46_indent_next{0};
constexpr std::array<element, 0> const line46_elements{{
}};

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

// paragraph
constexpr uint32_t const line48_indent_first{16};
constexpr uint32_t const line48_indent_next{16};
constexpr std::array<element, 11> const line48_elements{{
    {{} /* set() */, R"(Set the niceness of compression worker threads. Defaults to 5. This)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(ensures the ordering and segmenting threads are prioritised over compression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as they provide the data to the compression workers. On Windows, the values)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(are mapped as follows: 0 (zero) is mapped to "normal" priority, 1 to 5 are)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(mapped to "below normal" priority, 6 to 10 are mapped to "lowest" priority)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and values greater than 10 are mapped to "background" priority.)"} /* raw text */,
}};

constexpr uint32_t const line49_indent_first{0};
constexpr uint32_t const line49_indent_next{0};
constexpr std::array<element, 0> const line49_elements{{
}};

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

// paragraph
constexpr uint32_t const line51_indent_first{16};
constexpr uint32_t const line51_indent_next{16};
constexpr std::array<element, 23> const line51_elements{{
    {{} /* set() */, R"(Number of worker threads used for scanning the filesystem. Use this option)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(if you want to limit the resources used by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( or to optimize build)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(speed. This option affects only the scanning phase. By default, the same)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(value is used as for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-workers)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(In the scanning phase, the worker threads are used to scan files in the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(background as they are discovered. File scanning includes checksumming)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for de-duplication as well as (optionally) checksumming for similarity)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(computation, depending on the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order)"} /* inline code */,
    {{} /* set() */, R"( option. File discovery itself)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is single-threaded and runs independently from the scanning threads.)"} /* raw text */,
}};

constexpr uint32_t const line52_indent_first{0};
constexpr uint32_t const line52_indent_next{0};
constexpr std::array<element, 0> const line52_elements{{
}};

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

// paragraph
constexpr uint32_t const line54_indent_first{16};
constexpr uint32_t const line54_indent_next{16};
constexpr std::array<element, 25> const line54_elements{{
    {{} /* set() */, R"(Number of worker threads used for segmenting the input data. By default,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the same value is used as for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-workers)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Segmenting the input data is one of the most time consuming tasks when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(building a file system, and cannot easily be parallelized. However, when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(using the categorizer, a separate segmenter will be used for each category)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"((and subcategory, if present). This option controls how many segmenters)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(can run simultaneously. When )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compress-niceness)"} /* inline code */,
    {{} /* set() */, R"( is set to the default,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(segmenter threads will always have a higher priority than compression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(threads, making sure that compression doesn't slow down segmentation.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(This option also controls the number of threads used for ordering the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(input to the segmenter.)"} /* raw text */,
}};

constexpr uint32_t const line55_indent_first{0};
constexpr uint32_t const line55_indent_next{0};
constexpr std::array<element, 0> const line55_elements{{
}};

// paragraph
constexpr uint32_t const line56_indent_first{8};
constexpr uint32_t const line56_indent_next{8};
constexpr std::array<element, 7> const line56_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-B)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-lookback-blocks=[*category*)"} /* inline code */,
    {{} /* set() */, R"(::)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(])"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line57_indent_first{16};
constexpr uint32_t const line57_indent_next{16};
constexpr std::array<element, 36> const line57_elements{{
    {{} /* set() */, R"(Specify how many of the most recent blocks to scan for duplicate segments.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(By default, only the current block will be scanned ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-B 1)"} /* inline code */,
    {{} /* set() */, R"(). The larger this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(number, the more duplicate segments will likely be found, which may further)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(improve compression. Impact on compression speed should be minimal, but this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(could cause resulting filesystem to be less efficient to use, as single small)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(files can now potentially span multiple filesystem blocks. Definitely avoid)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(passing large values (i.e. larger than 10) here, especially in combination)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(with large block sizes, unless you know )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(exactly)"} /* raw text */,
    {{} /* set() */, R"( what you are doing. To give)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(give you an idea, using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-S 26)"} /* inline code */,
    {{} /* set() */, R"( (i.e. 64 MiB blocks) with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-B 32)"} /* inline code */,
    {{} /* set() */, R"( means)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that in the worst case, to read a single file of less than 1 MiB in size,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the file system may have to decompress 2 GiB of data. You have been warned.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(See )"} /* raw text */,
    {{} /* set() */, R"(Virtual Block Size)"} /* raw text */,
    {{} /* set() */, R"( for more details. Passing)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-B0)"} /* inline code */,
    {{} /* set() */, R"( will completely disable duplicate segment search.)"} /* 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, 7> const line59_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-W)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size=[*category*)"} /* inline code */,
    {{} /* set() */, R"(::)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(])"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* 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, 35> const line60_elements{{
    {{} /* set() */, R"(Window size of cyclic hash used for segmenting. This is an exponent)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to a base of two. Cyclic hashes are used by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( for finding)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(identical segments across multiple files. This is done on top of duplicate)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file detection. If a reasonable amount of duplicate segments is found,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(this means less blocks will be used in the filesystem and potentially)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(less memory will be used when accessing the filesystem. It doesn't)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(necessarily mean that the filesystem will be much smaller, as this removes)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(redundancy that cannot be exploited by the block compression any longer.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(But it shouldn't make the resulting filesystem any bigger. This option)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is used along with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-step)"} /* inline code */,
    {{} /* set() */, R"( to determine how extensive this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(segment search will be. The smaller the window sizes, the more segments)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will obviously be found. However, this also means files will become more)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fragmented and thus the filesystem can be slower to use and metadata)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(size will grow. Passing )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-W0)"} /* inline code */,
    {{} /* set() */, R"( will completely disable duplicate segment)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(search.)"} /* 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, 7> const line62_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-w)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-step=[*category*)"} /* inline code */,
    {{} /* set() */, R"(::)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(])"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* 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, 34> const line63_elements{{
    {{} /* set() */, R"(This option specifies how often cyclic hash values are stored for lookup.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(It is specified relative to the window size, as a base-2 exponent that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(divides the window size. As a concrete example, if )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size=16)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-step=1)"} /* inline code */,
    {{} /* set() */, R"(, then a cyclic hash across 65536 bytes will be stored)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(at every 32768 bytes of input data. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-step=2)"} /* inline code */,
    {{} /* set() */, R"(, then a hash value)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be stored at every 16384 bytes. This means that not every possible)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(65536-byte duplicate segment will be detected, but it is guaranteed that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(all duplicate segments of ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(window_size)"} /* inline code */,
    {{} /* set() */, R"( + )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(window_step)"} /* inline code */,
    {{} /* set() */, R"() bytes or more)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be detected (unless they span across block boundaries, of course).)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If you use a larger value for this option, the increments become )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(smaller)"} /* raw text */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( will be slightly slower and use more memory.)"} /* 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, 7> const line65_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--bloom-filter-size)"} /* inline code */,
    {{} /* set() */, R"(=[)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(category)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(::)"} /* inline code */,
    {{} /* set() */, R"(])"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* 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, 16> const line66_elements{{
    {{} /* set() */, R"(The segmenting algorithm uses a bloom filter to determine quickly if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(there is )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(no)"} /* raw text */,
    {{} /* set() */, R"( match at a given position. This will filter out more than)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(90% of bad matches quickly with the default bloom filter size. The default)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is pretty much where the sweet spot lies. If you have copious amounts of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(RAM and CPU power, feel free to increase this by one or two and you )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(might)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be able to see some improvement. If your system is tight on memory, then)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(decreasing this will potentially save a few MiBs.)"} /* 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, 5> const line68_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-L)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--memory-limit=auto|)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* 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, 27> const line69_elements{{
    {{} /* set() */, R"(Approximately how much memory you want )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( to use during filesystem)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(creation. Note that currently this will only affect the block manager)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(component, i.e. the number of filesystem blocks that are in flight but)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(haven't been compressed and written to the output file yet. So the memory)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(used by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( can certainly be larger than this limit, but it's a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(good option when building large filesystems with expensive compression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(algorithms. Also note that most memory is likely used by the compression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(algorithms, so if you're short on memory it might be worth tweaking the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression options. The default )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(auto)"} /* inline code */,
    {{} /* set() */, R"( mode will take into account the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(number of workers, the block size, and the amount of system memory to try)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to compute a reasonable limit.)"} /* 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, 17> const line71_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-C)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression=)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(category)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(::)"} /* inline code */,
    {{} /* set() */, R"(])"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(algorithm)"} /* 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"(algopt)"} /* 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"(value)"} /* raw text */,
    {{} /* set() */, R"(][)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(:)"} /* 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, 21> const line72_elements{{
    {{} /* set() */, R"(The compression algorithm and configuration used for file system data.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(The value for this option is a colon-separated list. The first item is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the compression algorithm, the remaining item are its options. Options)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(can be either boolean or have a value. For details on which algorithms)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and options are available, see the output of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs --help)"} /* inline code */,
    {{} /* set() */, R"(. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(zstd)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will give you the best compression while still keeping decompression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::emphasis::italic /* {'i'} */, R"(very)"} /* raw text */,
    {{} /* set() */, R"( fast. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(lzma)"} /* inline code */,
    {{} /* set() */, R"( will compress even better, but decompression will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be around ten times slower.)"} /* 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, 11> const line74_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--schema-compression=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(algorithm)"} /* 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"(algopt)"} /* 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"(value)"} /* raw text */,
    {{} /* set() */, R"(][)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(,)"} /* inline code */,
    {{} /* 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, 14> const line75_elements{{
    {{} /* set() */, R"(The compression algorithm and configuration used for the metadata schema.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Takes the same arguments as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"( above. The schema is )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(very)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(small, in the hundreds of bytes, so this is only relevant for extremely)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(small file systems. The default ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(zstd)"} /* inline code */,
    {{} /* set() */, R"() has shown to provide considerably)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(better results than any other algorithms.)"} /* 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, 11> const line77_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--metadata-compression=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(algorithm)"} /* 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"(algopt)"} /* 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"(value)"} /* raw text */,
    {{} /* set() */, R"(][)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(,)"} /* inline code */,
    {{} /* 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"(The compression algorithm and configuration used for the metadata.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Takes the same arguments as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"( above. The metadata has been)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(optimized for very little redundancy and leaving it uncompressed, the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(default for all levels below 7, has the benefit that it can be mapped)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to memory and used directly. This improves mount time for large file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(systems compared to e.g. an lzma compressed metadata block. If you don't)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(care about mount time, you can safely choose )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(lzma)"} /* inline code */,
    {{} /* set() */, R"( compression here, as)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the data will only have to be decompressed once when mounting the image.)"} /* 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, 11> const line80_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--history-compression=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(algorithm)"} /* 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"(algopt)"} /* 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"(value)"} /* raw text */,
    {{} /* set() */, R"(][)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(,)"} /* 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, 12> const line81_elements{{
    {{} /* set() */, R"(The compression algorithm and configuration used for the file system)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(history. Takes the same arguments as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"( above. Like the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(schema, history blocks are typically very small, so the default is the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(same as for schema compression. This is irrelevant if )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-history)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is present.)"} /* 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, 10> const line83_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=all)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=block)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=metadata)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=none)"} /* inline code */,
    {{} /* 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, 74> const line84_elements{{
    {{} /* set() */, R"(Take an existing DwarFS file system and recompress it using different)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression algorithms. If no argument or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"( is given, all sections)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in the file system image will be recompressed. Note that )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(only)"} /* raw text */,
    {{} /* set() */, R"( the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression algorithms, i.e. the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--schema-compression)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--metadata-compression)"} /* inline code */,
    {{} /* set() */, R"( options, have an impact on how the new file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system is written. Other options, e.g. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--block-size-bits)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(have no impact. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"( is given as an argument, none of the sections)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be recompressed, but the file system is still rewritten in the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(latest file system format. This is an easy way of upgrading an old file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system image to a new format. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(block)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(metadata)"} /* inline code */,
    {{} /* set() */, R"( is given, only)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the block sections (i.e. the actual file data) or the metadata sections)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(are recompressed. This can be useful if you want to switch from compressed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata to uncompressed metadata without having to rebuild or recompress)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(all the other data. See also )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--rebuild-metadata)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--change-block-size)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(which go way beyond just recompressing existing blocks. Note that when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(recompressing blocks with metadata-dependent compression algorithms (e.g.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(FLAC), the category metadata must be present in the file system metadata.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If the file system has been created with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-category-metadata)"} /* inline code */,
    {{} /* set() */, R"(, this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is no longer possible. Also note that even )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(if)"} /* raw text */,
    {{} /* set() */, R"( category metadata is present,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(recompressing blocks with a metadata-dependent compression algorithm may)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(require the use of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--change-block-size)"} /* inline code */,
    {{} /* set() */, R"(, as the compression algorithm may)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(have specific granularity requirements, which the blocks as previously stored)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(may not satisfy.)"} /* 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, 2> const line86_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--rebuild-metadata)"} /* inline code */,
    {{} /* 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, 39> const line87_elements{{
    {{} /* set() */, R"(Completely rebuild the metadata block. This will upgrade the internal format)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of the metadata to the latest version instead of just recompressing the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata block. Implies )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress=metadata)"} /* inline code */,
    {{} /* set() */, R"(. This will take into account)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the following options: )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--set-owner)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--set-group)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--set-time)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--keep-all-times)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--time-resolution)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--chmod)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--pack-metadata)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-metadata-version-history)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-category-names)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-category-metadata)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-create-timestamp)"} /* inline code */,
    {{} /* set() */, R"(. Note that most of these operations are not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(reversible, e.g. if you set a global owner or group, you cannot get back)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the original owners and groups.)"} /* 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, 2> const line89_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--change-block-size)"} /* inline code */,
    {{} /* 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, 22> const line90_elements{{
    {{} /* set() */, R"(Change the block size while recompressing. This will change the block size)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(according to the size given in )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--block-size-bits)"} /* inline code */,
    {{} /* set() */, R"(. Even if the block size)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is unchanged, this will still re-order and re-compress )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(all)"} /* raw text */,
    {{} /* set() */, R"( blocks. Implies)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress=all)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--rebuild-metadata)"} /* inline code */,
    {{} /* set() */, R"(. Note that changing the block)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(size to a different value and then back to the original value is not guaranteed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to produce a bit-identical file system image. Also note that this will not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(affect the )"} /* raw text */,
    {{} /* set() */, R"(Virtual Block Size)"} /* raw text */,
    {{} /* set() */, R"( of the file system.)"} /* 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{8};
constexpr std::array<element, 2> const line92_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-metadata-version-history)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line93_indent_first{16};
constexpr uint32_t const line93_indent_next{16};
constexpr std::array<element, 11> const line93_elements{{
    {{} /* set() */, R"(By default, when rebuilding the metadata block, a small history entry will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be added to the metadata block to keep track of versions and options across)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata rebuilds. It is recommended to keep this history, as it allows for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(better understanding of how the metadata block has changed over time and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(why it may be lacking certain features. If you know what you're doing, you)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(can use this option to disable this history completely.)"} /* raw text */,
}};

constexpr uint32_t const line94_indent_first{0};
constexpr uint32_t const line94_indent_next{0};
constexpr std::array<element, 0> const line94_elements{{
}};

// paragraph
constexpr uint32_t const line95_indent_first{8};
constexpr uint32_t const line95_indent_next{8};
constexpr std::array<element, 8> const line95_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress-categories=)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(!)"} /* inline code */,
    {{} /* set() */, R"(])"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(category)"} /* raw text */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(,)"} /* inline code */,
    {{} /* set() */, R"(...])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line96_indent_first{16};
constexpr uint32_t const line96_indent_next{16};
constexpr std::array<element, 19> const line96_elements{{
    {{} /* set() */, R"(When )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress)"} /* inline code */,
    {{} /* set() */, R"( is set to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(block)"} /* inline code */,
    {{} /* set() */, R"(, this option controls)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(which categories of blocks will be recompressed. Adding a )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(!)"} /* inline code */,
    {{} /* set() */, R"( in front)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of the list allows you to specify which categories will )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(not)"} /* raw text */,
    {{} /* set() */, R"( be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(recompressed. Cannot be used with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--change-block-size)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line97_indent_first{0};
constexpr uint32_t const line97_indent_next{0};
constexpr std::array<element, 0> const line97_elements{{
}};

// paragraph
constexpr uint32_t const line98_indent_first{8};
constexpr uint32_t const line98_indent_next{8};
constexpr std::array<element, 28> const line98_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-P)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--pack-metadata=auto)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"(|[)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(chunk_table)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(directories)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(shared_files)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names_index)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks_index)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(force)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(plain)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(,)"} /* inline code */,
    {{} /* set() */, R"(...]])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line99_indent_first{16};
constexpr uint32_t const line99_indent_next{16};
constexpr std::array<element, 28> const line99_elements{{
    {{} /* set() */, R"(Which metadata information to store in packed format. This is primarily)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(useful when storing metadata uncompressed, as it allows for smaller)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata block size without having to turn on compression. Keep in mind,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(though, that )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(most)"} /* raw text */,
    {{} /* set() */, R"( of the packed data must be unpacked into memory when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(reading the file system. If you want a purely memory-mappable metadata)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(block, leave this at the default ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(auto)"} /* inline code */,
    {{} /* set() */, R"(), which will turn on )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names)"} /* inline code */,
    {{} /* set() */, R"( and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks)"} /* inline code */,
    {{} /* set() */, R"( packing if these actually help save data.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Tweaking these options is mostly interesting when dealing with file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(systems that contain hundreds of thousands of files.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(See )"} /* raw text */,
    {{} /* set() */, R"(Metadata Packing)"} /* raw text */,
    {{} /* set() */, R"( for more details.)"} /* raw text */,
}};

constexpr uint32_t const line100_indent_first{0};
constexpr uint32_t const line100_indent_next{0};
constexpr std::array<element, 0> const line100_elements{{
}};

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

// paragraph
constexpr uint32_t const line102_indent_first{16};
constexpr uint32_t const line102_indent_next{16};
constexpr std::array<element, 5> const line102_elements{{
    {{} /* set() */, R"(Set the owner for all entities in the file system. This can reduce the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(size of the file system. If the input only has a single owner already,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(setting this won't make any difference.)"} /* raw text */,
}};

constexpr uint32_t const line103_indent_first{0};
constexpr uint32_t const line103_indent_next{0};
constexpr std::array<element, 0> const line103_elements{{
}};

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

// paragraph
constexpr uint32_t const line105_indent_first{16};
constexpr uint32_t const line105_indent_next{16};
constexpr std::array<element, 5> const line105_elements{{
    {{} /* set() */, R"(Set the group for all entities in the file system. This can reduce the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(size of the file system. If the input only has a single group already,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(setting this won't make any difference.)"} /* raw text */,
}};

constexpr uint32_t const line106_indent_first{0};
constexpr uint32_t const line106_indent_next{0};
constexpr std::array<element, 0> const line106_elements{{
}};

// paragraph
constexpr uint32_t const line107_indent_first{8};
constexpr uint32_t const line107_indent_next{8};
constexpr std::array<element, 6> const line107_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--set-time=now)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(iso-8601-string)"} /* raw text */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(unix-timestamp)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line108_indent_first{16};
constexpr uint32_t const line108_indent_next{16};
constexpr std::array<element, 21> const line108_elements{{
    {{} /* set() */, R"(Set the time stamps for all entities to this value. This can significantly)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(reduce the size of the file system. You can pass the string )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(now)"} /* inline code */,
    {{} /* set() */, R"( for the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(current time, an ISO 8601 string, or a unix timestamp (seconds since epoch).)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(The ISO 8601 string supports a space character instead of the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(T)"} /* inline code */,
    {{} /* set() */, R"( between)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(date and time and supports dashes as separators. Seconds or the full time)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(part may be omitted as long as this doesn't turn the whole string into a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(single number (i.e. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(2008-03-17)"} /* inline code */,
    {{} /* set() */, R"( is supported, but )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(20080317)"} /* inline code */,
    {{} /* set() */, R"( is not).)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line110_indent_first{8};
constexpr uint32_t const line110_indent_next{8};
constexpr std::array<element, 2> const line110_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--keep-all-times)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line111_indent_first{16};
constexpr uint32_t const line111_indent_next{16};
constexpr std::array<element, 12> const line111_elements{{
    {{} /* set() */, R"(As of release 0.3.0, by default, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( will only save the contents of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mtime)"} /* inline code */,
    {{} /* set() */, R"( field in order to save metadata space. If you want to save)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(atime)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ctime)"} /* inline code */,
    {{} /* set() */, R"( as well, use this option.)"} /* raw text */,
}};

constexpr uint32_t const line112_indent_first{0};
constexpr uint32_t const line112_indent_next{0};
constexpr std::array<element, 0> const line112_elements{{
}};

// 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{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--time-resolution=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(unit)"} /* raw text */,
    {{} /* set() */, R"(]|)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(unit)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line114_indent_first{16};
constexpr uint32_t const line114_indent_next{16};
constexpr std::array<element, 55> const line114_elements{{
    {{} /* set() */, R"(Specify the resolution with which time stamps are stored. By default,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(time stamps are stored with second resolution. You can specify "odd")"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(resolutions as well, e.g. something like 15 second resolution is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(entirely possible. Moving from second to minute resolution, for example,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will save roughly 6 bits per file system entry in the metadata block.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(The value must always be integral. Various units are supported, e.g.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ns)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(us)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* 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"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(d)"} /* inline code */,
    {{} /* set() */, R"(, or their longer equivalents )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(nsec)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(usec)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(msec)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(sec)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(min)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hour)"} /* inline code */,
    {{} /* set() */, R"(, and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(day)"} /* inline code */,
    {{} /* set() */, R"(. If no unit is given,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the value is assumed to be in seconds. Units can also be given without)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(a value, in which case a value of 1 is assumed. When rebuilding the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata, the resolution can be changed, but it cannot be increased,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(e.g. you cannot go from minute to second resolution. Also, changing)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the resolution requires that the new resolution is an integer multiple)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of the old resolution, e.g. you can go from 15 second to 30 second)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(resolution, but not from 15 second to 20 second resolution.)"} /* raw text */,
}};

constexpr uint32_t const line115_indent_first{0};
constexpr uint32_t const line115_indent_next{0};
constexpr std::array<element, 0> const line115_elements{{
}};

// paragraph
constexpr uint32_t const line116_indent_first{8};
constexpr uint32_t const line116_indent_next{8};
constexpr std::array<element, 8> const line116_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--chmod=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(mode)"} /* 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"(mode)"} /* raw text */,
    {{} /* set() */, R"(]...|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(norm)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line117_indent_first{16};
constexpr uint32_t const line117_indent_next{16};
constexpr std::array<element, 21> const line117_elements{{
    {{} /* set() */, R"(Recursively changes the mode bits of all entries in the generated file system.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Accepts the same mode specifications as the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(chmod)"} /* inline code */,
    {{} /* set() */, R"( utility and additionally)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(supports the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(D)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(F)"} /* inline code */,
    {{} /* set() */, R"( modifiers to limit a specification to directories)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(or non-directories. As a special case, you can pass )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--chmod=norm)"} /* inline code */,
    {{} /* set() */, R"( to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"("normalize" the permissions across the file system; this is equivalent to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--chmod=ug-st,=Xr)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line119_indent_first{8};
constexpr uint32_t const line119_indent_next{8};
constexpr std::array<element, 26> const line119_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order=)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(category)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(::)"} /* inline code */,
    {{} /* set() */, R"(])"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(path)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(revpath)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(similarity)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(nilsimsa)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(:)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(opt)"} /* 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"(value)"} /* raw text */,
    {{} /* set() */, R"(][)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(:)"} /* inline code */,
    {{} /* set() */, R"(...]]|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(explicit:file=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line120_indent_first{16};
constexpr uint32_t const line120_indent_next{16};
constexpr std::array<element, 77> const line120_elements{{
    {{} /* set() */, R"(The order in which inodes will be written to the file system. Choosing )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the inodes will be stored in the order in which they are discovered. When)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input-list)"} /* inline code */,
    {{} /* set() */, R"(, this will preserve the order of the input list. With)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(path)"} /* inline code */,
    {{} /* set() */, R"(, they will be sorted asciibetically by path name of the first file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(representing this inode. With )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(revpath)"} /* inline code */,
    {{} /* set() */, R"(, they will also be ordered by path)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(name, but the path is being traversed from the leaf to the root, i.e. files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(with the same name will be sorted next to each other. With )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(similarity)"} /* inline code */,
    {{} /* set() */, R"(, they)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be ordered using a simple, yet fast and efficient, similarity hash)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(function.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(nilsimsa)"} /* inline code */,
    {{} /* set() */, R"( ordering uses a more sophisticated similarity function that is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(typically better than )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(similarity)"} /* inline code */,
    {{} /* set() */, R"(, but can be significantly slower to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(determine a good ordering.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(However, the new implementation of this algorithm can be parallelized and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will perform much better on huge numbers of files. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(nilsimsa)"} /* inline code */,
    {{} /* set() */, R"( ordering can)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be tweaked by specifying )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-children)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"(. In general,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(larger values for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"( tend to result in better compression,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(but will slow down the algorithm quadratically. There is no point in setting)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"( larger than the number of files in the input.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Unlike the old implementation, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(nilsimsa)"} /* inline code */,
    {{} /* set() */, R"( ordering is now completely)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(deterministic. See )"} /* raw text */,
    {{} /* set() */, R"(Nilsimsa Ordering)"} /* raw text */,
    {{} /* set() */, R"( for a detailed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(description of the algorithm.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(explicit)"} /* inline code */,
    {{} /* set() */, R"( ordering allows you to specify a file that contains the paths in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the desired order. The paths must be relative to the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( path, but)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(may start with a leading )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line121_indent_first{0};
constexpr uint32_t const line121_indent_next{0};
constexpr std::array<element, 0> const line121_elements{{
}};

// paragraph
constexpr uint32_t const line122_indent_first{8};
constexpr uint32_t const line122_indent_next{8};
constexpr std::array<element, 3> const line122_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-similarity-size=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line123_indent_first{16};
constexpr uint32_t const line123_indent_next{16};
constexpr std::array<element, 11> const line123_elements{{
    {{} /* set() */, R"(Don't perform similarity ordering for fragments (or files if they are not split)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(into fragments by a categorizer) larger than this size. This helps speed up)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(scanning, especially on slow file systems. For large fragments, the gains from)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(similarity ordering are relatively small. When this option is set to a non-zero)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(value, fragments larger than the limit will be stored first, ordered by size in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(descending order.)"} /* raw text */,
}};

constexpr uint32_t const line124_indent_first{0};
constexpr uint32_t const line124_indent_next{0};
constexpr std::array<element, 0> const line124_elements{{
}};

// paragraph
constexpr uint32_t const line125_indent_first{8};
constexpr uint32_t const line125_indent_next{8};
constexpr std::array<element, 5> const line125_elements{{
    {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"(--filter=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(rule)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line126_indent_first{16};
constexpr uint32_t const line126_indent_next{16};
constexpr std::array<element, 5> const line126_elements{{
    {{} /* set() */, R"(Add a filter rule. This option can be specified multiple times.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(See )"} /* raw text */,
    {{} /* set() */, R"(FILTER RULES)"} /* raw text */,
    {{} /* set() */, R"( for more details.)"} /* raw text */,
}};

constexpr uint32_t const line127_indent_first{0};
constexpr uint32_t const line127_indent_next{0};
constexpr std::array<element, 0> const line127_elements{{
}};

// paragraph
constexpr uint32_t const line128_indent_first{8};
constexpr uint32_t const line128_indent_next{8};
constexpr std::array<element, 14> const line128_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--debug-filter)"} /* inline code */,
    {{} /* set() */, R"([)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=all)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=excluded)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=excluded-files)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=files)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=included)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(=included-files)"} /* inline code */,
    {{} /* set() */, R"(])"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line129_indent_first{16};
constexpr uint32_t const line129_indent_next{16};
constexpr std::array<element, 23> const line129_elements{{
    {{} /* set() */, R"(Show the effect of the filter rules without creating a file system.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If no argument is passed to the option, all included/excluded files and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(directories are shown (same as with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"(). )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(files)"} /* inline code */,
    {{} /* set() */, R"( will omit all)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(directories. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(included)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(excluded)"} /* inline code */,
    {{} /* set() */, R"( will only show the corresponding)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(set of files/directories. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(included-files)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(excluded-files)"} /* inline code */,
    {{} /* set() */, R"( work)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as before, but again omit all directories.)"} /* raw text */,
}};

constexpr uint32_t const line130_indent_first{0};
constexpr uint32_t const line130_indent_next{0};
constexpr std::array<element, 0> const line130_elements{{
}};

// paragraph
constexpr uint32_t const line131_indent_first{8};
constexpr uint32_t const line131_indent_next{8};
constexpr std::array<element, 2> const line131_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--remove-empty-dirs)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line132_indent_first{16};
constexpr uint32_t const line132_indent_next{16};
constexpr std::array<element, 5> const line132_elements{{
    {{} /* set() */, R"(Removes all empty directories from the output file system, recursively.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(This is particularly useful when using scripts that filter out a lot of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file system entries.)"} /* raw text */,
}};

constexpr uint32_t const line133_indent_first{0};
constexpr uint32_t const line133_indent_next{0};
constexpr std::array<element, 0> const line133_elements{{
}};

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

// paragraph
constexpr uint32_t const line135_indent_first{16};
constexpr uint32_t const line135_indent_next{16};
constexpr std::array<element, 21> const line135_elements{{
    {{} /* set() */, R"(Instead of actual file data, store each file as an empty sparse file with)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the same size as the original file. When accessing such a hollow file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system, it will behave just as if all files were actually present, but)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the data will be read as zeros. This can be useful if you want a somewhat)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(realistic representation of a file system, but you don't actually care)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(about the file contents. This does not work with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-sparse-files)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(You may want to set )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--file-hash=none)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order=none)"} /* inline code */,
    {{} /* set() */, R"( when using this)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(option to speed up the build process.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line137_indent_first{8};
constexpr uint32_t const line137_indent_next{8};
constexpr std::array<element, 2> const line137_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--with-devices)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line138_indent_first{16};
constexpr uint32_t const line138_indent_next{16};
constexpr std::array<element, 9> const line138_elements{{
    {{} /* set() */, R"(Include character and block devices in the output file system. These are)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(not included by default, and due to security measures in FUSE, they will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(never work in the mounted file system. However, they can still be copied)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(out of the mounted file system, for example using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(rsync)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line139_indent_first{0};
constexpr uint32_t const line139_indent_next{0};
constexpr std::array<element, 0> const line139_elements{{
}};

// paragraph
constexpr uint32_t const line140_indent_first{8};
constexpr uint32_t const line140_indent_next{8};
constexpr std::array<element, 2> const line140_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--with-specials)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line141_indent_first{16};
constexpr uint32_t const line141_indent_next{16};
constexpr std::array<element, 3> const line141_elements{{
    {{} /* set() */, R"(Include named fifos and sockets in the output file system. These are not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(included by default.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line143_indent_first{8};
constexpr uint32_t const line143_indent_next{8};
constexpr std::array<element, 2> const line143_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-sparse-files)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line144_indent_first{16};
constexpr uint32_t const line144_indent_next{16};
constexpr std::array<element, 9> const line144_elements{{
    {{} /* set() */, R"(By default, sparse files are detected and stored in a space-efficient)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(manner. However, file system images with sparse files cannot be read)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(by older versions of the DwarFS tools. If you need to maintain backward)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compatibility, you can use this option to disable sparse file support.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Sparse files will then be processed and stored like regular files.)"} /* 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{{
}};

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

// paragraph
constexpr uint32_t const line147_indent_first{16};
constexpr uint32_t const line147_indent_next{16};
constexpr std::array<element, 5> const line147_elements{{
    {{} /* set() */, R"(Read header from file and place it before the output filesystem image.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Can be used with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress)"} /* inline code */,
    {{} /* set() */, R"( to add or replace a header.)"} /* raw text */,
}};

constexpr uint32_t const line148_indent_first{0};
constexpr uint32_t const line148_indent_next{0};
constexpr std::array<element, 0> const line148_elements{{
}};

// paragraph
constexpr uint32_t const line149_indent_first{8};
constexpr uint32_t const line149_indent_next{8};
constexpr std::array<element, 2> const line149_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--remove-header)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line150_indent_first{16};
constexpr uint32_t const line150_indent_next{16};
constexpr std::array<element, 3> const line150_elements{{
    {{} /* set() */, R"(Remove header from a filesystem image. Only useful with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--recompress)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line152_indent_first{8};
constexpr uint32_t const line152_indent_next{8};
constexpr std::array<element, 2> const line152_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-section-index)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line153_indent_first{16};
constexpr uint32_t const line153_indent_next{16};
constexpr std::array<element, 5> const line153_elements{{
    {{} /* set() */, R"(Don't add section index to file system. The section index is usually tiny)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and is used to speed up mount times for large file systems, as it avoids)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(a full scan through the file system blocks to figure out their location.)"} /* raw text */,
}};

constexpr uint32_t const line154_indent_first{0};
constexpr uint32_t const line154_indent_next{0};
constexpr std::array<element, 0> const line154_elements{{
}};

// paragraph
constexpr uint32_t const line155_indent_first{8};
constexpr uint32_t const line155_indent_next{8};
constexpr std::array<element, 2> const line155_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-history)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line156_indent_first{16};
constexpr uint32_t const line156_indent_next{16};
constexpr std::array<element, 1> const line156_elements{{
    {{} /* set() */, R"(Don't add any history information to a file system.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line158_indent_first{8};
constexpr uint32_t const line158_indent_next{8};
constexpr std::array<element, 2> const line158_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-history-timestamps)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line159_indent_first{16};
constexpr uint32_t const line159_indent_next{16};
constexpr std::array<element, 6> const line159_elements{{
    {{} /* set() */, R"(Don't add timestamps to history entries. This is necessary, along with)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-create-timestamp)"} /* inline code */,
    {{} /* set() */, R"(, when trying to produce bit-identical file system)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(images.)"} /* raw text */,
}};

constexpr uint32_t const line160_indent_first{0};
constexpr uint32_t const line160_indent_next{0};
constexpr std::array<element, 0> const line160_elements{{
}};

// paragraph
constexpr uint32_t const line161_indent_first{8};
constexpr uint32_t const line161_indent_next{8};
constexpr std::array<element, 2> const line161_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-history-command-line)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line162_indent_first{16};
constexpr uint32_t const line162_indent_next{16};
constexpr std::array<element, 1> const line162_elements{{
    {{} /* set() */, R"(Don't record command line arguments in history entries.)"} /* raw text */,
}};

constexpr uint32_t const line163_indent_first{0};
constexpr uint32_t const line163_indent_next{0};
constexpr std::array<element, 0> const line163_elements{{
}};

// paragraph
constexpr uint32_t const line164_indent_first{8};
constexpr uint32_t const line164_indent_next{8};
constexpr std::array<element, 2> const line164_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-create-timestamp)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line165_indent_first{16};
constexpr uint32_t const line165_indent_next{16};
constexpr std::array<element, 3> const line165_elements{{
    {{} /* set() */, R"(Don't add a creation timestamp. This is useful when bit-identical file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system images are required to be produced from the same input.)"} /* raw text */,
}};

constexpr uint32_t const line166_indent_first{0};
constexpr uint32_t const line166_indent_next{0};
constexpr std::array<element, 0> const line166_elements{{
}};

// paragraph
constexpr uint32_t const line167_indent_first{8};
constexpr uint32_t const line167_indent_next{8};
constexpr std::array<element, 2> const line167_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-category-names)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line168_indent_first{16};
constexpr uint32_t const line168_indent_next{16};
constexpr std::array<element, 13> const line168_elements{{
    {{} /* set() */, R"(Don't add category names to the file system. This is only relevant if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the file system uses categories at all. Adding category names allows)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for setting per-category options when rewriting a file system, to get)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(per-category info with )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfsck)"} /* inline code */,
    {{} /* set() */, R"(, or to see the categories that have)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(been identified in a file. This implicitly adds )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-category-metadata)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line170_indent_first{8};
constexpr uint32_t const line170_indent_next{8};
constexpr std::array<element, 2> const line170_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-category-metadata)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line171_indent_first{16};
constexpr uint32_t const line171_indent_next{16};
constexpr std::array<element, 13> const line171_elements{{
    {{} /* set() */, R"(Don't add category metadata to the file system. This goes beyond just)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the category names and additionally stores the metadata identified)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(during categorization. This metadata is needed for metadata-dependent)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression algorithms (e.g. FLAC). So if you're planning to recompress)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(categorized blocks from a metadata-independent to a metadata-dependent)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression algorithm, this is going to be impossible if the metadata)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(information is not available.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line173_indent_first{8};
constexpr uint32_t const line173_indent_next{8};
constexpr std::array<element, 2> const line173_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-hardlink-table)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line174_indent_first{16};
constexpr uint32_t const line174_indent_next{16};
constexpr std::array<element, 17> const line174_elements{{
    {{} /* set() */, R"(Don't store hardlink counts in the inode table. If your input does not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(contain any hardlinks, there is no need to disable hardlink counts as)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(counts of one won't consume any space in the metadata. Really the only)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(reason why you might want to disable this is when you have lots of files,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(only a small number of them have hardlinks, and you want to save metadata)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(space by all means. If you disable hardlink counts, the information will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be reconstructed when the file system image is mounted, which consumes)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(both time and memory, although this will usually only be noticeable for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file system images with millions of files.)"} /* raw text */,
}};

constexpr uint32_t const line175_indent_first{0};
constexpr uint32_t const line175_indent_next{0};
constexpr std::array<element, 0> const line175_elements{{
}};

// paragraph
constexpr uint32_t const line176_indent_first{8};
constexpr uint32_t const line176_indent_next{8};
constexpr std::array<element, 4> const line176_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--file-hash=none)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(name)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line177_indent_first{16};
constexpr uint32_t const line177_indent_next{16};
constexpr std::array<element, 15> const line177_elements{{
    {{} /* set() */, R"(Select the hashing function to be used for file deduplication. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is chosen, file deduplication is disabled. By default, the built-in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(XXH3-128)"} /* inline code */,
    {{} /* set() */, R"( hash is used. This is not a secure hash function, but it is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(significantly faster. The full list of supported hash function depends)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(on the version of OpenSSL that the binary is linked against and is shown)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in the output of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs -h)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* 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{{
}};

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

// paragraph
constexpr uint32_t const line180_indent_first{16};
constexpr uint32_t const line180_indent_next{16};
constexpr std::array<element, 1> const line180_elements{{
    {{} /* set() */, R"(Specify a logging level.)"} /* raw text */,
}};

constexpr uint32_t const line181_indent_first{0};
constexpr uint32_t const line181_indent_next{0};
constexpr std::array<element, 0> const line181_elements{{
}};

// paragraph
constexpr uint32_t const line182_indent_first{8};
constexpr uint32_t const line182_indent_next{8};
constexpr std::array<element, 2> const line182_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--log-with-context)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line183_indent_first{16};
constexpr uint32_t const line183_indent_next{16};
constexpr std::array<element, 9> const line183_elements{{
    {{} /* set() */, R"(Enable logging context regardless of level. By default, context is enabled)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(if the level is )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(verbose)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(debug)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(trace)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line185_indent_first{8};
constexpr uint32_t const line185_indent_next{8};
constexpr std::array<element, 2> const line185_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-check)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line186_indent_first{16};
constexpr uint32_t const line186_indent_next{16};
constexpr std::array<element, 11> const line186_elements{{
    {{} /* set() */, R"(Skip the upfront integrity / checksum scan of the input filesystem before)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(starting recompression. For large, potentially remote filesystems, this can)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(save a significant amount of time because that initial validation pass is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(avoided. Errors will still be encountered if the input filesystem is not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(valid, but potentially only after a significant amount of time has been)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(spent on recompression.)"} /* raw text */,
}};

constexpr uint32_t const line187_indent_first{0};
constexpr uint32_t const line187_indent_next{0};
constexpr std::array<element, 0> const line187_elements{{
}};

// paragraph
constexpr uint32_t const line188_indent_first{8};
constexpr uint32_t const line188_indent_next{8};
constexpr std::array<element, 2> const line188_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-progress)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line189_indent_first{16};
constexpr uint32_t const line189_indent_next{16};
constexpr std::array<element, 1> const line189_elements{{
    {{} /* set() */, R"(Don't show progress output while building filesystem.)"} /* raw text */,
}};

constexpr uint32_t const line190_indent_first{0};
constexpr uint32_t const line190_indent_next{0};
constexpr std::array<element, 0> const line190_elements{{
}};

// paragraph
constexpr uint32_t const line191_indent_first{8};
constexpr uint32_t const line191_indent_next{8};
constexpr std::array<element, 8> const line191_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--progress=none)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(simple)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ascii)"} /* inline code */,
    {{} /* set() */, R"(|)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(unicode)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line192_indent_first{16};
constexpr uint32_t const line192_indent_next{16};
constexpr std::array<element, 26> const line192_elements{{
    {{} /* set() */, R"(Choosing )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"( is equivalent to specifying )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-progress)"} /* inline code */,
    {{} /* set() */, R"(. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(simple)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will print a single line of progress information whenever the progress)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(has significantly changed, but at most once every 2 seconds. This is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(also the default when the output is not a tty. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(unicode)"} /* inline code */,
    {{} /* set() */, R"( is the default)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(behaviour, which shows a nice progress bar and lots of additional)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(information. If your terminal cannot deal with unicode characters,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you can switch to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ascii)"} /* inline code */,
    {{} /* set() */, R"(, which is like )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(unicode)"} /* inline code */,
    {{} /* set() */, R"(, but looks less)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fancy.)"} /* 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{{
}};

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

// paragraph
constexpr uint32_t const line195_indent_first{16};
constexpr uint32_t const line195_indent_next{16};
constexpr std::array<element, 9> const line195_elements{{
    {{} /* set() */, R"(A file containing the paths of all "hot" files for the "hotness")"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(categorizer. The paths must be relative to the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( path, but)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(may start with a leading )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line196_indent_first{0};
constexpr uint32_t const line196_indent_next{0};
constexpr std::array<element, 0> const line196_elements{{
}};

// paragraph
constexpr uint32_t const line197_indent_first{8};
constexpr uint32_t const line197_indent_next{8};
constexpr std::array<element, 3> const line197_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--incompressible-min-input-size=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line198_indent_first{16};
constexpr uint32_t const line198_indent_next{16};
constexpr std::array<element, 5> const line198_elements{{
    {{} /* set() */, R"(The minimum size of a file to be checked for incompressibility when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"( categorizer is active.)"} /* 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{{
}};

// paragraph
constexpr uint32_t const line200_indent_first{8};
constexpr uint32_t const line200_indent_next{8};
constexpr std::array<element, 3> const line200_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--incompressible-block-size=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line201_indent_first{16};
constexpr uint32_t const line201_indent_next{16};
constexpr std::array<element, 5> const line201_elements{{
    {{} /* set() */, R"(The block size used to test data for compressibility. This will also)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be the size of the fragments when )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--incompressible-fragments)"} /* inline code */,
    {{} /* set() */, R"( is used.)"} /* raw text */,
}};

constexpr uint32_t const line202_indent_first{0};
constexpr uint32_t const line202_indent_next{0};
constexpr std::array<element, 0> const line202_elements{{
}};

// paragraph
constexpr uint32_t const line203_indent_first{8};
constexpr uint32_t const line203_indent_next{8};
constexpr std::array<element, 2> const line203_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--incompressible-fragments)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line204_indent_first{16};
constexpr uint32_t const line204_indent_next{16};
constexpr std::array<element, 3> const line204_elements{{
    {{} /* set() */, R"(Categorize individual fragments of a file as incompressible instead of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(only the file as a whole.)"} /* raw text */,
}};

constexpr uint32_t const line205_indent_first{0};
constexpr uint32_t const line205_indent_next{0};
constexpr std::array<element, 0> const line205_elements{{
}};

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

// paragraph
constexpr uint32_t const line207_indent_first{16};
constexpr uint32_t const line207_indent_next{16};
constexpr std::array<element, 3> const line207_elements{{
    {{} /* set() */, R"(The ratio above which a file or fragment is categorized as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line208_indent_first{0};
constexpr uint32_t const line208_indent_next{0};
constexpr std::array<element, 0> const line208_elements{{
}};

// paragraph
constexpr uint32_t const line209_indent_first{8};
constexpr uint32_t const line209_indent_next{8};
constexpr std::array<element, 3> const line209_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--incompressible-zstd-level=)"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(value)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line210_indent_first{16};
constexpr uint32_t const line210_indent_next{16};
constexpr std::array<element, 1> const line210_elements{{
    {{} /* set() */, R"(The ZSTD compression level used for incompressible categorization.)"} /* raw text */,
}};

constexpr uint32_t const line211_indent_first{0};
constexpr uint32_t const line211_indent_next{0};
constexpr std::array<element, 0> const line211_elements{{
}};

// paragraph
constexpr uint32_t const line212_indent_first{8};
constexpr uint32_t const line212_indent_next{8};
constexpr std::array<element, 4> const line212_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-h)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--help)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line213_indent_first{16};
constexpr uint32_t const line213_indent_next{16};
constexpr std::array<element, 1> const line213_elements{{
    {{} /* set() */, R"(Show usage and the most common basic options.)"} /* raw text */,
}};

constexpr uint32_t const line214_indent_first{0};
constexpr uint32_t const line214_indent_next{0};
constexpr std::array<element, 0> const line214_elements{{
}};

// paragraph
constexpr uint32_t const line215_indent_first{8};
constexpr uint32_t const line215_indent_next{8};
constexpr std::array<element, 4> const line215_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-H)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--long-help)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line216_indent_first{16};
constexpr uint32_t const line216_indent_next{16};
constexpr std::array<element, 3> const line216_elements{{
    {{} /* set() */, R"(Show full usage with all options, including defaults, compression level)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(detail and supported compression algorithms.)"} /* raw text */,
}};

constexpr uint32_t const line217_indent_first{0};
constexpr uint32_t const line217_indent_next{0};
constexpr std::array<element, 0> const line217_elements{{
}};

// paragraph
constexpr uint32_t const line218_indent_first{8};
constexpr uint32_t const line218_indent_next{16};
constexpr std::array<element, 11> const line218_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 line219_indent_first{0};
constexpr uint32_t const line219_indent_next{0};
constexpr std::array<element, 0> const line219_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3d70>
#endif
// paragraph
constexpr uint32_t const line221_indent_first{8};
constexpr uint32_t const line221_indent_next{8};
constexpr std::array<element, 7> const line221_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"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line222_indent_first{0};
constexpr uint32_t const line222_indent_next{0};
constexpr std::array<element, 0> const line222_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3ef0>
#endif
// paragraph
constexpr uint32_t const line224_indent_first{8};
constexpr uint32_t const line224_indent_next{8};
constexpr std::array<element, 9> const line224_elements{{
    {{} /* set() */, R"(Upon successful completion, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( will exit with exit code 0. If an)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(unrecoverable error occurs (i.e. no valid file system image has been produced),)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(it will exit with exit code 1. If any errors have occurred (e.g. not all input)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(files could be read), the exit code will be 2.)"} /* raw text */,
}};

constexpr uint32_t const line225_indent_first{0};
constexpr uint32_t const line225_indent_next{0};
constexpr std::array<element, 0> const line225_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3bf0>
#endif
// paragraph
constexpr uint32_t const line227_indent_first{8};
constexpr uint32_t const line227_indent_next{8};
constexpr std::array<element, 5> const line227_elements{{
    {{} /* set() */, R"(Categorizers will inspect the input files in the scanning phase and try to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(assign them a category. Each categorizer can define a set of categories,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and each of these categories can optionally support subcategories.)"} /* raw text */,
}};

constexpr uint32_t const line228_indent_first{0};
constexpr uint32_t const line228_indent_next{0};
constexpr std::array<element, 0> const line228_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4230>
#endif
// paragraph
constexpr uint32_t const line229_indent_first{8};
constexpr uint32_t const line229_indent_next{8};
constexpr std::array<element, 11> const line229_elements{{
    {{} /* set() */, R"(Running )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( with the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-H)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--long-help)"} /* inline code */,
    {{} /* set() */, R"( option will display the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(list of available categorizers and the categories they emit. Categorizers)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(may come with their own set of options if they allow for configuration.)"} /* raw text */,
}};

constexpr uint32_t const line230_indent_first{0};
constexpr uint32_t const line230_indent_next{0};
constexpr std::array<element, 0> const line230_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f45f0>
#endif
// paragraph
constexpr uint32_t const line231_indent_first{8};
constexpr uint32_t const line231_indent_next{8};
constexpr std::array<element, 27> const line231_elements{{
    {{} /* set() */, R"(Some categorizers are only useful if at least some of the configuration for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( is category-dependent. The options that can be configured per)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(category are )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-lookback-blocks)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-step)"} /* inline code */,
    {{} /* set() */, R"(, and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--bloom-filter-size)"} /* inline code */,
    {{} /* set() */, R"(. For example,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"( categorizer is really only useful if set the compression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(null)"} /* inline code */,
    {{} /* set() */, R"( for this category.)"} /* raw text */,
}};

constexpr uint32_t const line232_indent_first{0};
constexpr uint32_t const line232_indent_next{0};
constexpr std::array<element, 0> const line232_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4230>
#endif
// paragraph
constexpr uint32_t const line233_indent_first{8};
constexpr uint32_t const line233_indent_next{8};
constexpr std::array<element, 9> const line233_elements{{
    {{} /* set() */, R"(The resulting configuration matrix can be quite overwhelming, which is why)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( will run with a reasonable set of defaults if you specify the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--categorize)"} /* inline code */,
    {{} /* set() */, R"( option with no arguments. These defaults are also dependent)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(on the chosen compression level.)"} /* raw text */,
}};

constexpr uint32_t const line234_indent_first{0};
constexpr uint32_t const line234_indent_next{0};
constexpr std::array<element, 0> const line234_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f41d0>
#endif
// paragraph
constexpr uint32_t const line235_indent_first{8};
constexpr uint32_t const line235_indent_next{8};
constexpr std::array<element, 11> const line235_elements{{
    {{} /* set() */, R"(In case of categorizers with multiple categories, you can override each)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(option per category (e.g. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/waveform)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/metadata)"} /* inline code */,
    {{} /* set() */, R"( for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio)"} /* inline code */,
    {{} /* set() */, R"( categorizer).)"} /* raw text */,
}};

constexpr uint32_t const line236_indent_first{0};
constexpr uint32_t const line236_indent_next{0};
constexpr std::array<element, 0> const line236_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3d10>
#endif
// paragraph
constexpr uint32_t const line237_indent_first{8};
constexpr uint32_t const line237_indent_next{8};
constexpr std::array<element, 7> const line237_elements{{
    {{} /* set() */, R"(It's also worth noting that the order in which the categorizers are given)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is important. The first categorizer that will successfully categorize a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file wins and, if possible, no other categorizers will run on the same)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file.)"} /* raw text */,
}};

constexpr uint32_t const line238_indent_first{0};
constexpr uint32_t const line238_indent_next{0};
constexpr std::array<element, 0> const line238_elements{{
}};

#if 0
Heading(3, "incompressible" Categorizer, None)
#endif
constexpr uint32_t const line239_indent_first{4};
constexpr uint32_t const line239_indent_next{4};
constexpr std::array<element, 1> const line239_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"("incompressible" Categorizer)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3b90>
#endif
// paragraph
constexpr uint32_t const line240_indent_first{8};
constexpr uint32_t const line240_indent_next{8};
constexpr std::array<element, 13> const line240_elements{{
    {{} /* set() */, R"(The )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"( categorizer will try to compress each input with a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(very fast compression algorithm ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(zstd)"} /* inline code */,
    {{} /* set() */, R"( using a negative compression level)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(by default). If it turns out that this doesn't reduce the size of the input)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(significantly, the input will be categorized as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line241_indent_first{0};
constexpr uint32_t const line241_indent_next{0};
constexpr std::array<element, 0> const line241_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4a70>
#endif
// paragraph
constexpr uint32_t const line242_indent_first{8};
constexpr uint32_t const line242_indent_next{8};
constexpr std::array<element, 11> const line242_elements{{
    {{} /* set() */, R"(You can use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(incompressible)"} /* inline code */,
    {{} /* set() */, R"( categorizer in two modes: whole-file or)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fragmented categorization. In the former, the whole input file will be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(categorized, whereas in the latter, each file can be further broken down)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(into compressible and incompressible fragments. The size of these fragments)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be equal to the block size used for categorization.)"} /* raw text */,
}};

constexpr uint32_t const line243_indent_first{0};
constexpr uint32_t const line243_indent_next{0};
constexpr std::array<element, 0> const line243_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3fb0>
#endif
// paragraph
constexpr uint32_t const line244_indent_first{8};
constexpr uint32_t const line244_indent_next{8};
constexpr std::array<element, 7> const line244_elements{{
    {{} /* set() */, R"(It makes sense to use this categorizer as the last in a list of multiple)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(categorizers. Not only because it'll likely have the biggest overhead, but)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(also because it can wrongly classify data as incompressible that can be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compressed properly with a specialized algorithm (e.g. audio data).)"} /* raw text */,
}};

constexpr uint32_t const line245_indent_first{0};
constexpr uint32_t const line245_indent_next{0};
constexpr std::array<element, 0> const line245_elements{{
}};

#if 0
Heading(3, "pcmaudio" Categorizer, None)
#endif
constexpr uint32_t const line246_indent_first{4};
constexpr uint32_t const line246_indent_next{4};
constexpr std::array<element, 1> const line246_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"("pcmaudio" Categorizer)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3bf0>
#endif
// paragraph
constexpr uint32_t const line247_indent_first{8};
constexpr uint32_t const line247_indent_next{8};
constexpr std::array<element, 9> const line247_elements{{
    {{} /* set() */, R"(The )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio)"} /* inline code */,
    {{} /* set() */, R"( categorizer can identify and categorize a wide range of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(uncompressed audio data such as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(.wav)"} /* inline code */,
    {{} /* set() */, R"(, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(.aiff)"} /* inline code */,
    {{} /* set() */, R"( and more obscure formats.)"} /* raw text */,
}};

constexpr uint32_t const line248_indent_first{0};
constexpr uint32_t const line248_indent_next{0};
constexpr std::array<element, 0> const line248_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4470>
#endif
// paragraph
constexpr uint32_t const line249_indent_first{8};
constexpr uint32_t const line249_indent_next{8};
constexpr std::array<element, 15> const line249_elements{{
    {{} /* set() */, R"(It produces two different categories: )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/waveform)"} /* inline code */,
    {{} /* set() */, R"( for the actual)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(waveform data, and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/metadata)"} /* inline code */,
    {{} /* set() */, R"( for all other data in the file such)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as the file header. The )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/waveform)"} /* inline code */,
    {{} /* set() */, R"( category is again divided into)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(many subcategories depending on the type of waveform data (e.g. number of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(channels, bit depth, byte order, etc.).)"} /* raw text */,
}};

constexpr uint32_t const line250_indent_first{0};
constexpr uint32_t const line250_indent_next{0};
constexpr std::array<element, 0> const line250_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4710>
#endif
// paragraph
constexpr uint32_t const line251_indent_first{8};
constexpr uint32_t const line251_indent_next{8};
constexpr std::array<element, 12> const line251_elements{{
    {{} /* set() */, R"(In order to efficiently compress )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/waveform)"} /* inline code */,
    {{} /* set() */, R"( data, a suitable)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression algorithm must be selected for this category. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(currently supports )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(flac)"} /* inline code */,
    {{} /* set() */, R"( compression, which offers the best ratio of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression speed and achievable compression ratio.)"} /* raw text */,
}};

constexpr uint32_t const line252_indent_first{0};
constexpr uint32_t const line252_indent_next{0};
constexpr std::array<element, 0> const line252_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4950>
#endif
// paragraph
constexpr uint32_t const line253_indent_first{8};
constexpr uint32_t const line253_indent_next{8};
constexpr std::array<element, 21> const line253_elements{{
    {{} /* set() */, R"(It is worth noting that options such as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size)"} /* inline code */,
    {{} /* set() */, R"( will operate on)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::emphasis::italic /* {'i'} */, R"(sample)"} /* raw text */,
    {{} /* set() */, R"( granularity instead of )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(byte)"} /* raw text */,
    {{} /* set() */, R"( granularity when processing)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/waveform)"} /* inline code */,
    {{} /* set() */, R"( data, where )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(sample)"} /* raw text */,
    {{} /* set() */, R"( granularity means one sample)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for each channel. For example, a 16-bit stereo file would have a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(granularity of 4 bytes and thus )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size=10)"} /* inline code */,
    {{} /* set() */, R"( would refer to a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(4 KiB window instead of a 1 KiB windows.)"} /* raw text */,
}};

constexpr uint32_t const line254_indent_first{0};
constexpr uint32_t const line254_indent_next{0};
constexpr std::array<element, 0> const line254_elements{{
}};

#if 0
Heading(3, "fits" Categorizer, None)
#endif
constexpr uint32_t const line255_indent_first{4};
constexpr uint32_t const line255_indent_next{4};
constexpr std::array<element, 1> const line255_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"("fits" Categorizer)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3d10>
#endif
// paragraph
constexpr uint32_t const line256_indent_first{8};
constexpr uint32_t const line256_indent_next{8};
constexpr std::array<element, 7> const line256_elements{{
    {{} /* set() */, R"(The )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fits)"} /* inline code */,
    {{} /* set() */, R"( categorizer identifies )"} /* raw text */,
    {{} /* set() */, R"(FITS)"} /* raw text */,
    {{} /* set() */, R"( files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(used primarily in astrophotography.)"} /* raw text */,
}};

constexpr uint32_t const line257_indent_first{0};
constexpr uint32_t const line257_indent_next{0};
constexpr std::array<element, 0> const line257_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f44d0>
#endif
// paragraph
constexpr uint32_t const line258_indent_first{8};
constexpr uint32_t const line258_indent_next{8};
constexpr std::array<element, 18> const line258_elements{{
    {{} /* set() */, R"(Like the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio)"} /* inline code */,
    {{} /* set() */, R"( categorizer, it produces two categories: )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fits/image)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for the actual image data, and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fits/metadata)"} /* inline code */,
    {{} /* set() */, R"( for all other data in the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(file such as the file header. Also like the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio/waveform)"} /* inline code */,
    {{} /* set() */, R"( category,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fits/image)"} /* inline code */,
    {{} /* set() */, R"( category is further divided into subcategories depending)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(on the type of image data (e.g. bits per pixel, number of components).)"} /* raw text */,
}};

constexpr uint32_t const line259_indent_first{0};
constexpr uint32_t const line259_indent_next{0};
constexpr std::array<element, 0> const line259_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4890>
#endif
// paragraph
constexpr uint32_t const line260_indent_first{8};
constexpr uint32_t const line260_indent_next{8};
constexpr std::array<element, 11> const line260_elements{{
    {{} /* set() */, R"(In order to efficiently compress )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fits/image)"} /* inline code */,
    {{} /* set() */, R"( data, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( offers the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(ricepp)"} /* inline code */,
    {{} /* set() */, R"( compression algorithm, which is a C++ implementation of the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Rice compression algorithm)"} /* raw text */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line261_indent_first{0};
constexpr uint32_t const line261_indent_next{0};
constexpr std::array<element, 0> const line261_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f48f0>
#endif
// paragraph
constexpr uint32_t const line262_indent_first{8};
constexpr uint32_t const line262_indent_next{8};
constexpr std::array<element, 19> const line262_elements{{
    {{} /* set() */, R"(Just like for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(pcmaudio)"} /* inline code */,
    {{} /* set() */, R"(, options such as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--window-size)"} /* inline code */,
    {{} /* set() */, R"( will operate on)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::emphasis::italic /* {'i'} */, R"(pixel)"} /* raw text */,
    {{} /* set() */, R"( granularity instead of )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(byte)"} /* raw text */,
    {{} /* set() */, R"( granularity when processing )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(fits/image)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(data, where )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(pixel)"} /* raw text */,
    {{} /* set() */, R"( granularity means )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(all)"} /* raw text */,
    {{} /* set() */, R"( components of a pixel (e.g. a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(16-bit RGB image would have a granularity of 6 bytes).)"} /* raw text */,
}};

constexpr uint32_t const line263_indent_first{0};
constexpr uint32_t const line263_indent_next{0};
constexpr std::array<element, 0> const line263_elements{{
}};

#if 0
Heading(3, "binary" Categorizer, None)
#endif
constexpr uint32_t const line264_indent_first{4};
constexpr uint32_t const line264_indent_next{4};
constexpr std::array<element, 1> const line264_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"("binary" Categorizer)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4470>
#endif
// paragraph
constexpr uint32_t const line265_indent_first{8};
constexpr uint32_t const line265_indent_next{8};
constexpr std::array<element, 17> const line265_elements{{
    {{} /* set() */, R"(The )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(binary)"} /* inline code */,
    {{} /* set() */, R"( categorizer identifies executable files and shared libraries)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in ELF, PE, and Mach-O formats. More formats may be added in the future.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Subcategories will be created based on attributes such as architecture or)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(endianness. For ELF, PE, and thin Mach-O, the whole file will be categorized)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as a single fragment. For fat Mach-O files, each architecture slice will be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(treated as a separate fragment and any data/padding before, between, or after)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(slices will be categorized separately. Fat Mach-O slices and thin Mach-O files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(share the same subcategories.)"} /* raw text */,
}};

constexpr uint32_t const line266_indent_first{0};
constexpr uint32_t const line266_indent_next{0};
constexpr std::array<element, 0> const line266_elements{{
}};

#if 0
Heading(3, "hotness" Categorizer, None)
#endif
constexpr uint32_t const line267_indent_first{4};
constexpr uint32_t const line267_indent_next{4};
constexpr std::array<element, 1> const line267_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"("hotness" Categorizer)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4a70>
#endif
// paragraph
constexpr uint32_t const line268_indent_first{8};
constexpr uint32_t const line268_indent_next{8};
constexpr std::array<element, 18> const line268_elements{{
    {{} /* set() */, R"(The )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hotness)"} /* inline code */,
    {{} /* set() */, R"( categorizer will simply categorize files given in a hotness)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(list as )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(hot)"} /* inline code */,
    {{} /* set() */, R"(. All other files will be passed to categorizers further down)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the chain. This is intended to be used along with the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(analysis_file)"} /* inline code */,
    {{} /* set() */, R"( and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(preload_category)"} /* inline code */,
    {{} /* set() */, R"( options of the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(dwarfs)"} /* inline code */,
    {{} /* set() */, R"( FUSE driver to keep "hot" files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(clustered and potentially pre-cache them when mounting the file system.)"} /* raw text */,
}};

constexpr uint32_t const line269_indent_first{0};
constexpr uint32_t const line269_indent_next{0};
constexpr std::array<element, 0> const line269_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f40b0>
#endif
// paragraph
constexpr uint32_t const line270_indent_first{8};
constexpr uint32_t const line270_indent_next{8};
constexpr std::array<element, 3> const line270_elements{{
    {{} /* set() */, R"(It is quite possible that this categorizer will be replaced by a more)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(general mechanism to specify per-file categories in the future.)"} /* raw text */,
}};

constexpr uint32_t const line271_indent_first{0};
constexpr uint32_t const line271_indent_next{0};
constexpr std::array<element, 0> const line271_elements{{
}};

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

#if 0
Heading(3, Compression Ratio vs Decompression Speed, None)
#endif
constexpr uint32_t const line273_indent_first{4};
constexpr uint32_t const line273_indent_next{4};
constexpr std::array<element, 1> const line273_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Compression Ratio vs Decompression Speed)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3fb0>
#endif
// paragraph
constexpr uint32_t const line274_indent_first{8};
constexpr uint32_t const line274_indent_next{8};
constexpr std::array<element, 11> const line274_elements{{
    {{} /* set() */, R"(If high compression ratio is your primary goal, definitely go for lzma)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression. However, I've found that it's only about 10% better than)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(zstd at the highest level. The big advantage of zstd over lzma is that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(its decompression speed is about an order of magnitude faster. So if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you're extensively using the compressed file system, you'll probably)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(find that it's much faster with zstd.)"} /* raw text */,
}};

constexpr uint32_t const line275_indent_first{0};
constexpr uint32_t const line275_indent_next{0};
constexpr std::array<element, 0> const line275_elements{{
}};

#if 0
Heading(3, Block, Schema and Metadata Compression, None)
#endif
constexpr uint32_t const line276_indent_first{4};
constexpr uint32_t const line276_indent_next{4};
constexpr std::array<element, 1> const line276_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Block, Schema and Metadata Compression)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f45f0>
#endif
// paragraph
constexpr uint32_t const line277_indent_first{8};
constexpr uint32_t const line277_indent_next{8};
constexpr std::array<element, 21> const line277_elements{{
    {{} /* set() */, R"(DwarFS filesystems consist of three distinct parts of data: A potentially)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(large number of blocks, which store actual file data and are decompressed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(on demand, as well as one schema and one metadata section. The schema is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(tiny, typically less than 1000 bytes, and holds the details for how to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(interpret the metadata. The schema needs to be read into memory once and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is subsequently never accessed again. The metadata itself is compressed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(by default, but it doesn't have to be. Actually, if you drop the compression)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(level from 7 (the default) to 6, the only difference is that the metadata)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(is left uncompressed. This can be useful if mounting speed of the file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system is important, as the uncompressed metadata part of the file can)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(then simply be mapped into memory.)"} /* raw text */,
}};

constexpr uint32_t const line278_indent_first{0};
constexpr uint32_t const line278_indent_next{0};
constexpr std::array<element, 0> const line278_elements{{
}};

#if 0
Heading(3, Metadata Packing, None)
#endif
constexpr uint32_t const line279_indent_first{4};
constexpr uint32_t const line279_indent_next{4};
constexpr std::array<element, 1> const line279_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Metadata Packing)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4470>
#endif
// paragraph
constexpr uint32_t const line280_indent_first{8};
constexpr uint32_t const line280_indent_next{8};
constexpr std::array<element, 18> const line280_elements{{
    {{} /* set() */, R"(The filesystem metadata is stored in Frozen, a library that provides)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(serialization of data structures defined in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Thrift IDL)"} /* raw text */,
    {{} /* set() */, R"( into an extremely)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compact representation that can be used in-place without the need for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(deserialization. It is very well suited for persistent, memory-mappable)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(data. With Frozen, you essentially only "pay for what you use": if fields)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(are defined in the IDL, but they always hold the same value (or are not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(used at all), not a single bit will be allocated for this field even if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you have a list of millions of items.)"} /* raw text */,
}};

constexpr uint32_t const line281_indent_first{0};
constexpr uint32_t const line281_indent_next{0};
constexpr std::array<element, 0> const line281_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f46b0>
#endif
// paragraph
constexpr uint32_t const line282_indent_first{8};
constexpr uint32_t const line282_indent_next{8};
constexpr std::array<element, 13> const line282_elements{{
    {{} /* set() */, R"(Frozen metadata has relatively low redundancy and doesn't compress well,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(but you can still save around 30-50% by enabling compression. However,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(this means that upon reading the filesystem, you will first have to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fully decompress the metadata block and keep it in memory. An uncompressed)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(block could simply be mapped into memory and would be instantly usable.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(So, if e.g. mounting speed is a concern, it would make sense to disable)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata compression, in particular for large filesystems.)"} /* raw text */,
}};

constexpr uint32_t const line283_indent_first{0};
constexpr uint32_t const line283_indent_next{0};
constexpr std::array<element, 0> const line283_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3d10>
#endif
// paragraph
constexpr uint32_t const line284_indent_first{8};
constexpr uint32_t const line284_indent_next{8};
constexpr std::array<element, 7> const line284_elements{{
    {{} /* set() */, R"(However, there are several options to choose from that allow you to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(further reduce metadata size without having to compress the metadata.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(These options are controlled by the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--pack-metadata)"} /* inline code */,
    {{} /* set() */, R"( option.)"} /* raw text */,
}};

constexpr uint32_t const line285_indent_first{0};
constexpr uint32_t const line285_indent_next{0};
constexpr std::array<element, 0> const line285_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7f0c3b7f48f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f4470>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7f50>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f56d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f5d90>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f62d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f7a70>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f78f0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f6bd0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f60f0>], list item)]
#endif
// paragraph
constexpr uint32_t const line286_indent_first{8};
constexpr uint32_t const line286_indent_next{16};
constexpr std::array<element, 7> const line286_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(auto)"} /* inline code */,
    {{} /* set() */, R"(    )"} /* raw text */,
    {{} /* set() */, R"(This is the default. It will enable both )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line287_indent_first{0};
constexpr uint32_t const line287_indent_next{0};
constexpr std::array<element, 0> const line287_elements{{
}};

// paragraph
constexpr uint32_t const line288_indent_first{8};
constexpr uint32_t const line288_indent_next{16};
constexpr std::array<element, 9> const line288_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"(    )"} /* raw text */,
    {{} /* set() */, R"(Don't enable any packing. However, string tables (i.e. names and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(symlinks) will still be stored in "compact" rather than "plain")"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(format. In order to force storage in plain format, use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(plain)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line289_indent_first{0};
constexpr uint32_t const line289_indent_next{0};
constexpr std::array<element, 0> const line289_elements{{
}};

// paragraph
constexpr uint32_t const line290_indent_first{8};
constexpr uint32_t const line290_indent_next{16};
constexpr std::array<element, 14> const line290_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"(     )"} /* raw text */,
    {{} /* set() */, R"(Enable all packing options. This does )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(not)"} /* raw text */,
    {{} /* set() */, R"( force packing of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(string tables (i.e. names and symlinks) if the packing would)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(actually increase the size, which can happen if the string tables)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(are actually small. In order to force string table packing, use)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all,force)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line291_indent_first{0};
constexpr uint32_t const line291_indent_next{0};
constexpr std::array<element, 0> const line291_elements{{
}};

// paragraph
constexpr uint32_t const line292_indent_first{8};
constexpr uint32_t const line292_indent_next{8};
constexpr std::array<element, 2> const line292_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(chunk_table)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line293_indent_first{16};
constexpr uint32_t const line293_indent_next{16};
constexpr std::array<element, 7> const line293_elements{{
    {{} /* set() */, R"(Delta-compress chunk tables. This can reduce the size of the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(chunk tables for large file systems and help compression, however,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(it will likely require a lot of memory when unpacking the tables)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(again. Only use this if you know what you're doing.)"} /* raw text */,
}};

constexpr uint32_t const line294_indent_first{0};
constexpr uint32_t const line294_indent_next{0};
constexpr std::array<element, 0> const line294_elements{{
}};

// paragraph
constexpr uint32_t const line295_indent_first{8};
constexpr uint32_t const line295_indent_next{8};
constexpr std::array<element, 2> const line295_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(directories)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line296_indent_first{16};
constexpr uint32_t const line296_indent_next{16};
constexpr std::array<element, 13> const line296_elements{{
    {{} /* set() */, R"(Pack directories table by storing first entry pointers delta-)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compressed and completely removing parent directory pointers.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(The parent directory pointers can be rebuilt by tree traversal)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(when the filesystem is loaded. If you have a large number of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(directories, this can reduce the metadata size, however, it)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will likely require a lot of memory when unpacking the tables)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(again. Only use this if you know what you're doing.)"} /* raw text */,
}};

constexpr uint32_t const line297_indent_first{0};
constexpr uint32_t const line297_indent_next{0};
constexpr std::array<element, 0> const line297_elements{{
}};

// paragraph
constexpr uint32_t const line298_indent_first{8};
constexpr uint32_t const line298_indent_next{8};
constexpr std::array<element, 2> const line298_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(shared_files)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line299_indent_first{16};
constexpr uint32_t const line299_indent_next{16};
constexpr std::array<element, 5> const line299_elements{{
    {{} /* set() */, R"(Pack shared files table. This is only useful if the filesystem)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(contains lots of non-hardlinked duplicates. It gets more efficient)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the more copies of a file are in the filesystem.)"} /* raw text */,
}};

constexpr uint32_t const line300_indent_first{0};
constexpr uint32_t const line300_indent_next{0};
constexpr std::array<element, 0> const line300_elements{{
}};

// paragraph
constexpr uint32_t const line301_indent_first{8};
constexpr uint32_t const line301_indent_next{8};
constexpr std::array<element, 4> const line301_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line302_indent_first{16};
constexpr uint32_t const line302_indent_next{16};
constexpr std::array<element, 28> const line302_elements{{
    {{} /* set() */, R"(Compress the names and symlink targets using the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fsst)"} /* raw text */,
    {{} /* set() */, R"( compression scheme. This)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compresses each individual entry separately using a small,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(custom symbol table, and it's surprisingly efficient. It is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(not uncommon for names to make up for 50-70% of the metadata,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and fsst compression typically reduces the size by a factor)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(of two. The entries can be decompressed individually, so no)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(extra memory is used when accessing the filesystem (except for)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the symbol table, which is only a few hundred bytes). This is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(enabled by default. For small filesystems, it's possible that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the compressed strings plus symbol table are actually larger)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(than the uncompressed strings. If this is the case, the strings)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be stored uncompressed, unless )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(force)"} /* inline code */,
    {{} /* set() */, R"( is also specified.)"} /* raw text */,
}};

constexpr uint32_t const line303_indent_first{0};
constexpr uint32_t const line303_indent_next{0};
constexpr std::array<element, 0> const line303_elements{{
}};

// paragraph
constexpr uint32_t const line304_indent_first{8};
constexpr uint32_t const line304_indent_next{8};
constexpr std::array<element, 4> const line304_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names_index)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks_index)"} /* inline code */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line305_indent_first{16};
constexpr uint32_t const line305_indent_next{16};
constexpr std::array<element, 5> const line305_elements{{
    {{} /* set() */, R"(Delta-compress the names and symlink targets indices. The same)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(caveats apply as for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(chunk_table)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line306_indent_first{0};
constexpr uint32_t const line306_indent_next{0};
constexpr std::array<element, 0> const line306_elements{{
}};

// paragraph
constexpr uint32_t const line307_indent_first{8};
constexpr uint32_t const line307_indent_next{16};
constexpr std::array<element, 13> const line307_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(force)"} /* inline code */,
    {{} /* set() */, R"(   )"} /* raw text */,
    {{} /* set() */, R"(Forces the compression of the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(names)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(symlinks)"} /* inline code */,
    {{} /* set() */, R"( tables,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(even if that would make them use more memory than the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(uncompressed tables. This is really only useful for testing)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and development.)"} /* raw text */,
}};

constexpr uint32_t const line308_indent_first{0};
constexpr uint32_t const line308_indent_next{0};
constexpr std::array<element, 0> const line308_elements{{
}};

// paragraph
constexpr uint32_t const line309_indent_first{8};
constexpr uint32_t const line309_indent_next{16};
constexpr std::array<element, 7> const line309_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(plain)"} /* inline code */,
    {{} /* set() */, R"(   )"} /* raw text */,
    {{} /* set() */, R"(Store string tables in "plain" format. The plain format uses)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Frozen thrift arrays and was used in earlier metadata versions.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(It is useful for debugging, but wastes up to one byte per string.)"} /* raw text */,
}};

constexpr uint32_t const line310_indent_first{0};
constexpr uint32_t const line310_indent_next{0};
constexpr std::array<element, 0> const line310_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f7cb0>
#endif
// paragraph
constexpr uint32_t const line311_indent_first{8};
constexpr uint32_t const line311_indent_next{8};
constexpr std::array<element, 11> const line311_elements{{
    {{} /* set() */, R"(To give you an idea of the metadata size using different packing options,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(here's the size of the metadata block for the Ubuntu 20.04.2.0 Desktop)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(ISO image. There are just over 200,000 files in this image. The ZSTD)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and LZMA columns show to what fraction it is possible to reduce the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(metadata size by additional compression. That fraction is relative to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the corresponding packing option.)"} /* raw text */,
}};

constexpr uint32_t const line312_indent_first{0};
constexpr uint32_t const line312_indent_next{0};
constexpr std::array<element, 0> const line312_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7f0c3ba82e90>
#endif
// raw text
constexpr uint32_t const line313_indent_first{12};
constexpr uint32_t const line313_indent_next{12};
constexpr std::array<element, 1> const line313_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(---------|---------------|-----------|---------|---------)"} /* None */,
}};

// raw text
constexpr uint32_t const line314_indent_first{12};
constexpr uint32_t const line314_indent_next{12};
constexpr std::array<element, 1> const line314_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"( Packing | Metadata Size | Relative  | ZSTD    | LZMA)"} /* None */,
}};

// raw text
constexpr uint32_t const line315_indent_first{12};
constexpr uint32_t const line315_indent_next{12};
constexpr std::array<element, 1> const line315_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(---------|---------------|-----------|---------|---------)"} /* None */,
}};

// raw text
constexpr uint32_t const line316_indent_first{12};
constexpr uint32_t const line316_indent_next{12};
constexpr std::array<element, 1> const line316_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"( auto    |     5,301,177 |   100.00% |  57.33% |  49.29%)"} /* None */,
}};

// raw text
constexpr uint32_t const line317_indent_first{12};
constexpr uint32_t const line317_indent_next{12};
constexpr std::array<element, 1> const line317_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"( all     |     4,952,859 |    93.43% |  50.46% |  46.45%)"} /* None */,
}};

// raw text
constexpr uint32_t const line318_indent_first{12};
constexpr uint32_t const line318_indent_next{12};
constexpr std::array<element, 1> const line318_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"( none    |     6,337,294 |   119.55% |  47.70% |  41.37%)"} /* None */,
}};

// raw text
constexpr uint32_t const line319_indent_first{12};
constexpr uint32_t const line319_indent_next{12};
constexpr std::array<element, 1> const line319_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"( plain   |     6,430,275 |   121.30% |  48.36% |  41.37%)"} /* None */,
}};

// raw text
constexpr uint32_t const line320_indent_first{12};
constexpr uint32_t const line320_indent_next{12};
constexpr std::array<element, 1> const line320_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(---------|---------------|-----------|---------|---------)"} /* None */,
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4170>
#endif
// paragraph
constexpr uint32_t const line322_indent_first{8};
constexpr uint32_t const line322_indent_next{8};
constexpr std::array<element, 23> const line322_elements{{
    {{} /* set() */, R"(So, the default ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(auto)"} /* inline code */,
    {{} /* set() */, R"() is roughly 20% smaller than not using any)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(packing ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(none)"} /* inline code */,
    {{} /* set() */, R"( or )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(plain)"} /* inline code */,
    {{} /* set() */, R"(). Enabling )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"( packing options doesn't)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(reduce the size much more. However, it )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(does)"} /* raw text */,
    {{} /* set() */, R"( help if you want to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(further compress the block. So, if you're really desperately trying)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to reduce the image size, enabling )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(all)"} /* inline code */,
    {{} /* set() */, R"( packing would be an option)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(at the cost of using a lot more memory when using the filesystem.)"} /* raw text */,
}};

constexpr uint32_t const line323_indent_first{0};
constexpr uint32_t const line323_indent_next{0};
constexpr std::array<element, 0> const line323_elements{{
}};

#if 0
Heading(3, Producing bit-identical images, None)
#endif
constexpr uint32_t const line324_indent_first{4};
constexpr uint32_t const line324_indent_next{4};
constexpr std::array<element, 1> const line324_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Producing bit-identical images)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3dd0>
#endif
// paragraph
constexpr uint32_t const line325_indent_first{8};
constexpr uint32_t const line325_indent_next{8};
constexpr std::array<element, 7> const line325_elements{{
    {{} /* set() */, R"(By default, images produced by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( will not be identical)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(over multiple runs. This is due to time stamps that are being added)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to the file system image.)"} /* raw text */,
}};

constexpr uint32_t const line326_indent_first{0};
constexpr uint32_t const line326_indent_next{0};
constexpr std::array<element, 0> const line326_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f67b0>
#endif
// paragraph
constexpr uint32_t const line327_indent_first{8};
constexpr uint32_t const line327_indent_next{8};
constexpr std::array<element, 9> const line327_elements{{
    {{} /* set() */, R"(In order to produce bit-identical images, you need to pass)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-create-timestamp)"} /* inline code */,
    {{} /* set() */, R"( and either )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-history-timestamps)"} /* inline code */,
    {{} /* set() */, R"( or)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--no-history)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line328_indent_first{0};
constexpr uint32_t const line328_indent_next{0};
constexpr std::array<element, 0> const line328_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4530>
#endif
// paragraph
constexpr uint32_t const line329_indent_first{8};
constexpr uint32_t const line329_indent_next{8};
constexpr std::array<element, 15> const line329_elements{{
    {{} /* set() */, R"(Another more subtle requirement for bit-identical images is that if)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you're using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--categorize)"} /* inline code */,
    {{} /* set() */, R"(, the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-segmenter-workers)"} /* inline code */,
    {{} /* set() */, R"( is kept)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(constant. Since the default number of workers depends on the physical)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(processor count, if you want images produced on different systems with)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(different processor count to be bit-identical, you should explicitly)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(set the number of segmenter workers.)"} /* raw text */,
}};

constexpr uint32_t const line330_indent_first{0};
constexpr uint32_t const line330_indent_next{0};
constexpr std::array<element, 0> const line330_elements{{
}};

#if 0
Heading(3, Virtual Block Size, None)
#endif
constexpr uint32_t const line331_indent_first{4};
constexpr uint32_t const line331_indent_next{4};
constexpr std::array<element, 1> const line331_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Virtual Block Size)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4830>
#endif
// paragraph
constexpr uint32_t const line332_indent_first{8};
constexpr uint32_t const line332_indent_next{8};
constexpr std::array<element, 27> const line332_elements{{
    {{} /* set() */, R"(The concept of "virtual block size" is useful when thinking about)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the resource requirements of a file system image. )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( already)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(allows you to choose very large block sizes. While this is helpful)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for high compression ratios, it also increases the CPU and memory)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(requirements when accessing files in the file system. For example,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(reading a 1,000 byte file from a DwarFS image with a block size of)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(16 MiB will require decompressing )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(at least)"} /* raw text */,
    {{} /* set() */, R"( one full 16 MiB block.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(If the file is split across two blocks, )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(both)"} /* raw text */,
    {{} /* set() */, R"( blocks will have to be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(decompressed. These blocks will end up in the cache, in case they)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(are needed for subsequent reads, but if this is the only file you're)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(going to read, that is a lot of wasted effort.)"} /* raw text */,
}};

constexpr uint32_t const line333_indent_first{0};
constexpr uint32_t const line333_indent_next{0};
constexpr std::array<element, 0> const line333_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4770>
#endif
// paragraph
constexpr uint32_t const line334_indent_first{8};
constexpr uint32_t const line334_indent_next{8};
constexpr std::array<element, 10> const line334_elements{{
    {{} /* set() */, R"(Usually, you won't really notice this, as decompression is )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(really)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fast. However, if you're doing a lot of random reads of (small) files)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that are spread across a large number of blocks and these blocks don't)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fit into the cache, you will notice a significant slowdown, as the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(same blocks will have to be decompressed over and over again.)"} /* raw text */,
}};

constexpr uint32_t const line335_indent_first{0};
constexpr uint32_t const line335_indent_next{0};
constexpr std::array<element, 0> const line335_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4c50>
#endif
// paragraph
constexpr uint32_t const line336_indent_first{8};
constexpr uint32_t const line336_indent_next{8};
constexpr std::array<element, 30> const line336_elements{{
    {{} /* set() */, R"(So far, this is quite straightforward. It gets more interesting when)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(you start to also use )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-lookback-blocks)"} /* inline code */,
    {{} /* set() */, R"( when building a DwarFS)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(image. This option, while tempting to use to get better compression,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will increase the "virtual" size of file system blocks. Specifying)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-lookback-blocks=4)"} /* inline code */,
    {{} /* set() */, R"( means that each file can potentially refer)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to chunks of data in up to 4 blocks, even if it is itself much smaller)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(than a single block. Combining this with a block size of 16 MiB means)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that each file access will potentially require decompressing up to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(64 MiB of data. This is the "virtual block size" of the file system.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(So, while a combination of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-S26 -B16)"} /* inline code */,
    {{} /* set() */, R"( may look quite innocent, it)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(actually produces a file system with a virtual block size of 1 GiB,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(meaning a single file access can potentially completely exhaust the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(cache.)"} /* raw text */,
}};

constexpr uint32_t const line337_indent_first{0};
constexpr uint32_t const line337_indent_next{0};
constexpr std::array<element, 0> const line337_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f5730>
#endif
// paragraph
constexpr uint32_t const line338_indent_first{8};
constexpr uint32_t const line338_indent_next{8};
constexpr std::array<element, 15> const line338_elements{{
    {{} /* set() */, R"(So please keep this concept in mind when choosing the options to build)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(your file system image. Something like )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(-S26 -B16)"} /* inline code */,
    {{} /* set() */, R"( )"} /* raw text */,
    {fmt::emphasis::italic /* {'i'} */, R"(may)"} /* raw text */,
    {{} /* set() */, R"( be totally)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(fine if you have plenty of RAM and your primary goal is for the image)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to be as small as possible. However, if you want a file system image)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that is optimized for random access speed, you should stick to smaller)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"((virtual) block sizes.)"} /* raw text */,
}};

constexpr uint32_t const line339_indent_first{0};
constexpr uint32_t const line339_indent_next{0};
constexpr std::array<element, 0> const line339_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4830>
#endif
// paragraph
constexpr uint32_t const line340_indent_first{8};
constexpr uint32_t const line340_indent_next{8};
constexpr std::array<element, 15> const line340_elements{{
    {{} /* set() */, R"(Also keep in mind that you cannot change the virtual block size of an)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(existing file system image. While you can change the physical block)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(size using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--change-block-size)"} /* inline code */,
    {{} /* set() */, R"(, e.g. go from 16 MiB to 1 MiB, the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(virtual block size will remain the same since a file can still refer)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(to data in all of the 16 blocks that the original 16 MiB block was)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(split into. The resulting file system will be very similar to one that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(was built with a block size of 1 MiB and 16 blocks of lookback.)"} /* raw text */,
}};

constexpr uint32_t const line341_indent_first{0};
constexpr uint32_t const line341_indent_next{0};
constexpr std::array<element, 0> const line341_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3ad0>
#endif
// paragraph
constexpr uint32_t const line343_indent_first{8};
constexpr uint32_t const line343_indent_next{8};
constexpr std::array<element, 7> const line343_elements{{
    {{} /* set() */, R"(The filter rules have been inspired by the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(rsync)"} /* inline code */,
    {{} /* set() */, R"( utility. These)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(look very similar, though there are differences. These rules are quite)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(powerful, yet they're somewhat hard to get used to.)"} /* raw text */,
}};

constexpr uint32_t const line344_indent_first{0};
constexpr uint32_t const line344_indent_next{0};
constexpr std::array<element, 0> const line344_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3e30>
#endif
// paragraph
constexpr uint32_t const line345_indent_first{8};
constexpr uint32_t const line345_indent_next{8};
constexpr std::array<element, 1> const line345_elements{{
    {{} /* set() */, R"(There are only 3 different kinds of rules:)"} /* raw text */,
}};

constexpr uint32_t const line346_indent_first{0};
constexpr uint32_t const line346_indent_next{0};
constexpr std::array<element, 0> const line346_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7f0c3b7a3bf0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7a3d70>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f41d0>], list item)]
#endif
// paragraph
constexpr uint32_t const line347_indent_first{8};
constexpr uint32_t const line347_indent_next{8};
constexpr std::array<element, 3> const line347_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(+ )"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(pattern)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line348_indent_first{16};
constexpr uint32_t const line348_indent_next{16};
constexpr std::array<element, 1> const line348_elements{{
    {{} /* set() */, R"(An "include" rule.)"} /* raw text */,
}};

constexpr uint32_t const line349_indent_first{0};
constexpr uint32_t const line349_indent_next{0};
constexpr std::array<element, 0> const line349_elements{{
}};

// paragraph
constexpr uint32_t const line350_indent_first{8};
constexpr uint32_t const line350_indent_next{8};
constexpr std::array<element, 3> const line350_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(- )"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(pattern)"} /* raw text */,
    {{} /* set() */, R"()"} /* raw text */,
}};

// paragraph
constexpr uint32_t const line351_indent_first{16};
constexpr uint32_t const line351_indent_next{16};
constexpr std::array<element, 1> const line351_elements{{
    {{} /* set() */, R"(An "exclude" rule.)"} /* raw text */,
}};

constexpr uint32_t const line352_indent_first{0};
constexpr uint32_t const line352_indent_next{0};
constexpr std::array<element, 0> const line352_elements{{
}};

// paragraph
constexpr uint32_t const line353_indent_first{8};
constexpr uint32_t const line353_indent_next{16};
constexpr std::array<element, 6> const line353_elements{{
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(. )"} /* inline code */,
    {fmt::emphasis::italic /* {'i'} */, R"(file)"} /* raw text */,
    {{} /* set() */, R"(  )"} /* raw text */,
    {{} /* set() */, R"(A merge file rule. Rules are read (recursively) from the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(specified file.)"} /* raw text */,
}};

constexpr uint32_t const line354_indent_first{0};
constexpr uint32_t const line354_indent_next{0};
constexpr std::array<element, 0> const line354_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3cb0>
#endif
// paragraph
constexpr uint32_t const line355_indent_first{8};
constexpr uint32_t const line355_indent_next{8};
constexpr std::array<element, 3> const line355_elements{{
    {{} /* set() */, R"(Ultimately, only include and exclude rules remain in the rule set)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as file rules are merged in at the place where they occur.)"} /* raw text */,
}};

constexpr uint32_t const line356_indent_first{0};
constexpr uint32_t const line356_indent_next{0};
constexpr std::array<element, 0> const line356_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3ad0>
#endif
// paragraph
constexpr uint32_t const line357_indent_first{8};
constexpr uint32_t const line357_indent_next{8};
constexpr std::array<element, 7> const line357_elements{{
    {{} /* set() */, R"(The most important rule to remember when building a rule set is that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(all rules are applied strictly in order and processing stops at the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(first matching rule. If no rules match, the default is to include the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(entry.)"} /* raw text */,
}};

constexpr uint32_t const line358_indent_first{0};
constexpr uint32_t const line358_indent_next{0};
constexpr std::array<element, 0> const line358_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f6ab0>
#endif
// paragraph
constexpr uint32_t const line359_indent_first{8};
constexpr uint32_t const line359_indent_next{8};
constexpr std::array<element, 11> const line359_elements{{
    {{} /* set() */, R"(Patterns can be anchored or floating. Anchored patterns are patterns)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(that start with a )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/)"} /* inline code */,
    {{} /* set() */, R"(. These patterns match relative to the file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system root (i.e. the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--input)"} /* inline code */,
    {{} /* set() */, R"( path). Floating patterns match in)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(any directory in the hierarchy.)"} /* raw text */,
}};

constexpr uint32_t const line360_indent_first{0};
constexpr uint32_t const line360_indent_next{0};
constexpr std::array<element, 0> const line360_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3b90>
#endif
// paragraph
constexpr uint32_t const line361_indent_first{8};
constexpr uint32_t const line361_indent_next{8};
constexpr std::array<element, 5> const line361_elements{{
    {{} /* set() */, R"(Patterns ending with a )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/)"} /* inline code */,
    {{} /* set() */, R"( only match directories. All other patterns)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(only match non-directories.)"} /* raw text */,
}};

constexpr uint32_t const line362_indent_first{0};
constexpr uint32_t const line362_indent_next{0};
constexpr std::array<element, 0> const line362_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3e30>
#endif
// paragraph
constexpr uint32_t const line363_indent_first{8};
constexpr uint32_t const line363_indent_next{8};
constexpr std::array<element, 5> const line363_elements{{
    {{} /* set() */, R"(Note that regardless of the preferred native directory separator,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(filter rules will always use UNIX-style directory separators ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/)"} /* inline code */,
    {{} /* set() */, R"().)"} /* raw text */,
}};

constexpr uint32_t const line364_indent_first{0};
constexpr uint32_t const line364_indent_next{0};
constexpr std::array<element, 0> const line364_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4710>
#endif
// paragraph
constexpr uint32_t const line365_indent_first{8};
constexpr uint32_t const line365_indent_next{8};
constexpr std::array<element, 11> const line365_elements{{
    {{} /* set() */, R"(Patterns support )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(?)"} /* inline code */,
    {{} /* set() */, R"( and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(*)"} /* inline code */,
    {{} /* set() */, R"( wildcards matching a single character)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and any number of characters, respectively. These patterns don't match)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(across directory separators ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(/)"} /* inline code */,
    {{} /* set() */, R"().)"} /* raw text */,
}};

constexpr uint32_t const line366_indent_first{0};
constexpr uint32_t const line366_indent_next{0};
constexpr std::array<element, 0> const line366_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3ef0>
#endif
// paragraph
constexpr uint32_t const line367_indent_first{8};
constexpr uint32_t const line367_indent_next{8};
constexpr std::array<element, 5> const line367_elements{{
    {{} /* set() */, R"(Patterns also support the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(**)"} /* inline code */,
    {{} /* set() */, R"( globstar wildcard, which matches across)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(directory separators.)"} /* raw text */,
}};

constexpr uint32_t const line368_indent_first{0};
constexpr uint32_t const line368_indent_next{0};
constexpr std::array<element, 0> const line368_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4710>
#endif
// paragraph
constexpr uint32_t const line369_indent_first{8};
constexpr uint32_t const line369_indent_next{8};
constexpr std::array<element, 9> const line369_elements{{
    {{} /* set() */, R"(Patterns also support character classes ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"([avt])"} /* inline code */,
    {{} /* set() */, R"(), ranges ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"([a-h])"} /* inline code */,
    {{} /* set() */, R"(),)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and complementation ()"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"([!a-h])"} /* inline code */,
    {{} /* set() */, R"().)"} /* raw text */,
}};

constexpr uint32_t const line370_indent_first{0};
constexpr uint32_t const line370_indent_next{0};
constexpr std::array<element, 0> const line370_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3e30>
#endif
// paragraph
constexpr uint32_t const line371_indent_first{8};
constexpr uint32_t const line371_indent_next{8};
constexpr std::array<element, 1> const line371_elements{{
    {{} /* set() */, R"(Here's an exemplary rule set:)"} /* raw text */,
}};

constexpr uint32_t const line372_indent_first{0};
constexpr uint32_t const line372_indent_next{0};
constexpr std::array<element, 0> const line372_elements{{
}};

#if 0
<__main__.BlockCode object at 0x7f0c3b9788a0>
#endif
// raw text
constexpr uint32_t const line373_indent_first{12};
constexpr uint32_t const line373_indent_next{12};
constexpr std::array<element, 1> const line373_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(+ File/Spec/[EM]*.pm)"} /* None */,
}};

// raw text
constexpr uint32_t const line374_indent_first{12};
constexpr uint32_t const line374_indent_next{12};
constexpr std::array<element, 1> const line374_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(- unicore/**.pl)"} /* None */,
}};

// raw text
constexpr uint32_t const line375_indent_first{12};
constexpr uint32_t const line375_indent_next{12};
constexpr std::array<element, 1> const line375_elements{{
    {fmt::emphasis::faint /* {'block'} */, R"(+ *.pl)"} /* None */,
}};

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

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3dd0>
#endif
// paragraph
constexpr uint32_t const line378_indent_first{8};
constexpr uint32_t const line378_indent_next{8};
constexpr std::array<element, 12> const line378_elements{{
    {{} /* set() */, R"(This set of rules will include all files matching )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(File/Spec/[EM]*.pm)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(anywhere in the hierarchy. It will also include all )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(*.pl)"} /* inline code */,
    {{} /* set() */, R"( files, except)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(for those anywhere below a )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(unicore)"} /* inline code */,
    {{} /* set() */, R"( directory. The last rule excludes)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(all other files.)"} /* raw text */,
}};

constexpr uint32_t const line379_indent_first{0};
constexpr uint32_t const line379_indent_next{0};
constexpr std::array<element, 0> const line379_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f60f0>
#endif
// paragraph
constexpr uint32_t const line380_indent_first{8};
constexpr uint32_t const line380_indent_next{8};
constexpr std::array<element, 5> const line380_elements{{
    {{} /* set() */, R"(This will likely leave a lot of empty directories around, but these can)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(be removed using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--remove-empty-dirs)"} /* inline code */,
    {{} /* set() */, R"(.)"} /* raw text */,
}};

constexpr uint32_t const line381_indent_first{0};
constexpr uint32_t const line381_indent_next{0};
constexpr std::array<element, 0> const line381_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3ad0>
#endif
// paragraph
constexpr uint32_t const line382_indent_first{8};
constexpr uint32_t const line382_indent_next{8};
constexpr std::array<element, 5> const line382_elements{{
    {{} /* set() */, R"(You can use the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--debug-filter)"} /* inline code */,
    {{} /* set() */, R"( option to show the sets of included)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(and excluded files without building an actual file system.)"} /* raw text */,
}};

constexpr uint32_t const line383_indent_first{0};
constexpr uint32_t const line383_indent_next{0};
constexpr std::array<element, 0> const line383_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7f60f0>
#endif
// paragraph
constexpr uint32_t const line385_indent_first{8};
constexpr uint32_t const line385_indent_next{8};
constexpr std::array<element, 14> const line385_elements{{
    {{} /* set() */, R"(Internally, )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(mkdwarfs)"} /* inline code */,
    {{} /* set() */, R"( runs in two completely separate phases. The first)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(phase is scanning the input data, the second phase is building the file)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(system. Both phases try to do as little work as possible, and try to run)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as much of the remaining work as possible in parallel, while still making)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(sure that the file system images produced are reproducible (see the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order)"} /* inline code */,
    {{} /* set() */, R"( option documentation for details on reproducible images).)"} /* raw text */,
}};

constexpr uint32_t const line386_indent_first{0};
constexpr uint32_t const line386_indent_next{0};
constexpr std::array<element, 0> const line386_elements{{
}};

#if 0
Heading(3, Scanning, None)
#endif
constexpr uint32_t const line387_indent_first{4};
constexpr uint32_t const line387_indent_next{4};
constexpr std::array<element, 1> const line387_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Scanning)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3d10>
#endif
// paragraph
constexpr uint32_t const line388_indent_first{8};
constexpr uint32_t const line388_indent_next{8};
constexpr std::array<element, 11> const line388_elements{{
    {{} /* set() */, R"(The scanning process is driven by the main thread which traverses the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(input directory recursively and builds an internal representation of the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(directory structure. Traversal is breadth-first and single-threaded.)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(Filter rules as specified by )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--filter)"} /* inline code */,
    {{} /* set() */, R"( are handled immediately during)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(traversal.)"} /* raw text */,
}};

constexpr uint32_t const line389_indent_first{0};
constexpr uint32_t const line389_indent_next{0};
constexpr std::array<element, 0> const line389_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f47d0>
#endif
// paragraph
constexpr uint32_t const line390_indent_first{8};
constexpr uint32_t const line390_indent_next{8};
constexpr std::array<element, 33> const line390_elements{{
    {{} /* set() */, R"(When a regular file is discovered, its hardlink count is checked and)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(if greater than one, its inode is looked up in a hardlink cache. Another)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(lookup is performed to see if this is the first file/inode of a particular)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(size. If it's the first file, we just keep track of the file. If it's not)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the first file, we add a job to a pool of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-scanner-workers)"} /* inline code */,
    {{} /* set() */, R"( worker)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(threads to compute a hash (which hash function is used is determined by)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--file-hash)"} /* inline code */,
    {{} /* set() */, R"( option) of the file. We also add a hash-computing)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(job for the first file we found with this size earlier. These hashes will)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(then be used for de-duplicating files. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--order)"} /* inline code */,
    {{} /* set() */, R"( is set to one of the)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(similarity order modes, for each unique file, a further job is added to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the pool to compute a similarity hash. This happens immediately for each)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(inode of a unique size, but it is guaranteed that duplicates don't trigger)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(another similarity hash scan (the implementation for this is actually a bit)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(tricky).)"} /* raw text */,
}};

constexpr uint32_t const line391_indent_first{0};
constexpr uint32_t const line391_indent_next{0};
constexpr std::array<element, 0> const line391_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3e30>
#endif
// paragraph
constexpr uint32_t const line392_indent_first{8};
constexpr uint32_t const line392_indent_next{8};
constexpr std::array<element, 3> const line392_elements{{
    {{} /* set() */, R"(Once all file contents have been scanned by the worker threads, all)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(unique files will be assigned an internal inode number.)"} /* raw text */,
}};

constexpr uint32_t const line393_indent_first{0};
constexpr uint32_t const line393_indent_next{0};
constexpr std::array<element, 0> const line393_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f4830>
#endif
// paragraph
constexpr uint32_t const line394_indent_first{8};
constexpr uint32_t const line394_indent_next{8};
constexpr std::array<element, 13> const line394_elements{{
    {{} /* set() */, R"(This behaviour can be customized. When using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--file-hash=none)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(de-duplication is completely disabled. Using )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-similarity-size)"} /* inline code */,
    {{} /* set() */, R"(,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(it is possible to prevent computation of similarity hashes for huge)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(files. These huge files will then be stored separately before all other)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(files in the image.)"} /* raw text */,
}};

constexpr uint32_t const line395_indent_first{0};
constexpr uint32_t const line395_indent_next{0};
constexpr std::array<element, 0> const line395_elements{{
}};

#if 0
Heading(3, Building, None)
#endif
constexpr uint32_t const line396_indent_first{4};
constexpr uint32_t const line396_indent_next{4};
constexpr std::array<element, 1> const line396_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Building)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3dd0>
#endif
// paragraph
constexpr uint32_t const line397_indent_first{8};
constexpr uint32_t const line397_indent_next{8};
constexpr std::array<element, 3> const line397_elements{{
    {{} /* set() */, R"(Building the filesystem image uses a )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-workers)"} /* inline code */,
    {{} /* set() */, R"( separate threads.)"} /* raw text */,
}};

constexpr uint32_t const line398_indent_first{0};
constexpr uint32_t const line398_indent_next{0};
constexpr std::array<element, 0> const line398_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f6150>
#endif
// paragraph
constexpr uint32_t const line399_indent_first{8};
constexpr uint32_t const line399_indent_next{8};
constexpr std::array<element, 14> const line399_elements{{
    {{} /* set() */, R"(If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(nilsimsa)"} /* inline code */,
    {{} /* set() */, R"( ordering is selected, the ordering algorithm runs in its)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(own thread and continuously emits file inodes. These will be picked up)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(by the segmenter thread, which scans the inode contents using a cyclic)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(hash and determines overlapping segments between previously written)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(data and new incoming data. The segmenter will look at up to)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--max-lookback-blocks)"} /* inline code */,
    {{} /* set() */, R"( previous filesystem blocks to find overlaps.)"} /* raw text */,
}};

constexpr uint32_t const line400_indent_first{0};
constexpr uint32_t const line400_indent_next{0};
constexpr std::array<element, 0> const line400_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f6ab0>
#endif
// paragraph
constexpr uint32_t const line401_indent_first{8};
constexpr uint32_t const line401_indent_next{8};
constexpr std::array<element, 11> const line401_elements{{
    {{} /* set() */, R"(Once the segmenter has produced enough data to fill a filesystem)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(block, the block is added to a queue where from which the blocks)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be picked up by a pool of )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--num-workers)"} /* inline code */,
    {{} /* set() */, R"( worker threads whose)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(only job is to compress the block using the )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(--compression)"} /* inline code */,
    {{} /* set() */, R"( algorithm.)"} /* raw text */,
}};

constexpr uint32_t const line402_indent_first{0};
constexpr uint32_t const line402_indent_next{0};
constexpr std::array<element, 0> const line402_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3b30>
#endif
// paragraph
constexpr uint32_t const line403_indent_first{8};
constexpr uint32_t const line403_indent_next{8};
constexpr std::array<element, 5> const line403_elements{{
    {{} /* set() */, R"(Blocks that have been compressed will be added to the next queue,)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in the original order, and will be picked up by the filesystem writer)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(thread that will ultimately produce the final filesystem image.)"} /* raw text */,
}};

constexpr uint32_t const line404_indent_first{0};
constexpr uint32_t const line404_indent_next{0};
constexpr std::array<element, 0> const line404_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3d10>
#endif
// paragraph
constexpr uint32_t const line405_indent_first{8};
constexpr uint32_t const line405_indent_next{8};
constexpr std::array<element, 7> const line405_elements{{
    {{} /* set() */, R"(When all data has been segmented, the filesystem metadata is being)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(finalized and frozen into a compact representation. If metadata)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(compression is enabled, the metadata is sent to the worker thread)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(pool for compression.)"} /* raw text */,
}};

constexpr uint32_t const line406_indent_first{0};
constexpr uint32_t const line406_indent_next{0};
constexpr std::array<element, 0> const line406_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3ad0>
#endif
// paragraph
constexpr uint32_t const line407_indent_first{8};
constexpr uint32_t const line407_indent_next{8};
constexpr std::array<element, 5> const line407_elements{{
    {{} /* set() */, R"(When using different ordering schemes, the file inodes will be)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(either sorted upfront, or just sent to the segmenter in the order)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(in which they were discovered.)"} /* raw text */,
}};

constexpr uint32_t const line408_indent_first{0};
constexpr uint32_t const line408_indent_next{0};
constexpr std::array<element, 0> const line408_elements{{
}};

#if 0
Heading(3, Nilsimsa Ordering, None)
#endif
constexpr uint32_t const line409_indent_first{4};
constexpr uint32_t const line409_indent_next{4};
constexpr std::array<element, 1> const line409_elements{{
    {fmt::fg(fmt::terminal_color::bright_green) | fmt::emphasis::bold /* {'h3', 'head'} */, R"(Nilsimsa Ordering)"} /* raw text */,
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3b90>
#endif
// paragraph
constexpr uint32_t const line410_indent_first{8};
constexpr uint32_t const line410_indent_next{8};
constexpr std::array<element, 9> const line410_elements{{
    {{} /* set() */, R"(The actual ordering step for nilsimsa ordering uses a recursive)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(divide-and-conquer approach in order for the algorithm to be both)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(parallelizable and deterministic. In the following description, a)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"("node" is typically equivalent to a "unique file", although that's)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(not a requirement for the algorithm.)"} /* raw text */,
}};

constexpr uint32_t const line411_indent_first{0};
constexpr uint32_t const line411_indent_next{0};
constexpr std::array<element, 0> const line411_elements{{
}};

#if 0
[ListItem([<__main__.Paragraph object at 0x7f0c3b7f4830>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f4530>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f56d0>], list item), ListItem([<__main__.Paragraph object at 0x7f0c3b7f4d10>], list item)]
#endif
// paragraph
constexpr uint32_t const line412_indent_first{8};
constexpr uint32_t const line412_indent_next{8};
constexpr std::array<element, 14> const line412_elements{{
    {{} /* set() */, R"(Nodes are clustered by distance to centroids into up to )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-children)"} /* inline code */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(clusters. With )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-children)"} /* inline code */,
    {{} /* set() */, R"( set to 1, all nodes end up in the same)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(cluster. If )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-children)"} /* inline code */,
    {{} /* set() */, R"( is larger than 1, a new cluster is created)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(as soon as all existing clusters are further away than a "maximum)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(distance" that gets smaller as recursion depth increases.)"} /* raw text */,
}};

constexpr uint32_t const line413_indent_first{0};
constexpr uint32_t const line413_indent_next{0};
constexpr std::array<element, 0> const line413_elements{{
}};

// paragraph
constexpr uint32_t const line414_indent_first{8};
constexpr uint32_t const line414_indent_next{8};
constexpr std::array<element, 8> const line414_elements{{
    {{} /* set() */, R"(After the nodes have been clustered, each cluster that is larger than)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"( is recursively clustered again with a smaller)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"("maximum distance" as per (1). These recursive clustering steps can)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(potentially run in parallel.)"} /* raw text */,
}};

constexpr uint32_t const line415_indent_first{0};
constexpr uint32_t const line415_indent_next{0};
constexpr std::array<element, 0> const line415_elements{{
}};

// paragraph
constexpr uint32_t const line416_indent_first{8};
constexpr uint32_t const line416_indent_next{8};
constexpr std::array<element, 11> const line416_elements{{
    {{} /* set() */, R"(As soon as a cluster is smaller than )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"(, its nodes)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(will be ordered by performing a nearest neighbour search. Note that)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(this only happens for leaf clusters in the tree. The ordering of each)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(leaf cluster can also run parallel with clustering / ordering of other)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(clusters.)"} /* raw text */,
}};

constexpr uint32_t const line417_indent_first{0};
constexpr uint32_t const line417_indent_next{0};
constexpr std::array<element, 0> const line417_elements{{
}};

// paragraph
constexpr uint32_t const line418_indent_first{8};
constexpr uint32_t const line418_indent_next{8};
constexpr std::array<element, 7> const line418_elements{{
    {{} /* set() */, R"(Once all clustering / ordering is done, the nodes are "collected" from)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(the clusters in the tree. There is currently no similarity ordering)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(between individual clusters, but this is something that can be explored)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(further in the future.)"} /* raw text */,
}};

constexpr uint32_t const line419_indent_first{0};
constexpr uint32_t const line419_indent_next{0};
constexpr std::array<element, 0> const line419_elements{{
}};

#if 0
<__main__.Paragraph object at 0x7f0c3b7f58b0>
#endif
// paragraph
constexpr uint32_t const line420_indent_first{8};
constexpr uint32_t const line420_indent_next{8};
constexpr std::array<element, 19> const line420_elements{{
    {{} /* set() */, R"(By setting )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-children)"} /* inline code */,
    {{} /* set() */, R"( to 1 and )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"( to a really large)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(number, only a single cluster will be created and the nearest neighbour)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(search will be performed on the set of all nodes. Since the algorithm is)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(O(n^2), this does not scale well for )"} /* raw text */,
    {fmt::fg(fmt::terminal_color::bright_blue) | fmt::emphasis::bold /* {'code'} */, R"(max-cluster-size)"} /* inline code */,
    {{} /* set() */, R"( beyond a few)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(100,000. Also, since the algorithm does not minimize the global distance)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(between all nodes, there's no guarantee that the result will be better)"} /* raw text */,
    {{} /* set() */, R"( )"} /* whitespace */,
    {{} /* set() */, R"(if you use only a single cluster.)"} /* raw text */,
}};

constexpr uint32_t const line421_indent_first{0};
constexpr uint32_t const line421_indent_next{0};
constexpr std::array<element, 0> const line421_elements{{
}};

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

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

constexpr uint32_t const line424_indent_first{0};
constexpr uint32_t const line424_indent_next{0};
constexpr std::array<element, 0> const line424_elements{{
}};

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

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

constexpr uint32_t const line427_indent_first{0};
constexpr uint32_t const line427_indent_next{0};
constexpr std::array<element, 0> const line427_elements{{
}};

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

#if 0
<__main__.Paragraph object at 0x7f0c3b7a3e90>
#endif
// paragraph
constexpr uint32_t const line429_indent_first{8};
constexpr uint32_t const line429_indent_next{8};
constexpr std::array<element, 9> const line429_elements{{
    {{} /* set() */, R"(dwarfs(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 line430_indent_first{0};
constexpr uint32_t const line430_indent_next{0};
constexpr std::array<element, 0> const line430_elements{{
}};

constexpr std::array<line, 431> 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},
    {line211_indent_first, line211_indent_next, line211_elements},
    {line212_indent_first, line212_indent_next, line212_elements},
    {line213_indent_first, line213_indent_next, line213_elements},
    {line214_indent_first, line214_indent_next, line214_elements},
    {line215_indent_first, line215_indent_next, line215_elements},
    {line216_indent_first, line216_indent_next, line216_elements},
    {line217_indent_first, line217_indent_next, line217_elements},
    {line218_indent_first, line218_indent_next, line218_elements},
    {line219_indent_first, line219_indent_next, line219_elements},
    {line220_indent_first, line220_indent_next, line220_elements},
    {line221_indent_first, line221_indent_next, line221_elements},
    {line222_indent_first, line222_indent_next, line222_elements},
    {line223_indent_first, line223_indent_next, line223_elements},
    {line224_indent_first, line224_indent_next, line224_elements},
    {line225_indent_first, line225_indent_next, line225_elements},
    {line226_indent_first, line226_indent_next, line226_elements},
    {line227_indent_first, line227_indent_next, line227_elements},
    {line228_indent_first, line228_indent_next, line228_elements},
    {line229_indent_first, line229_indent_next, line229_elements},
    {line230_indent_first, line230_indent_next, line230_elements},
    {line231_indent_first, line231_indent_next, line231_elements},
    {line232_indent_first, line232_indent_next, line232_elements},
    {line233_indent_first, line233_indent_next, line233_elements},
    {line234_indent_first, line234_indent_next, line234_elements},
    {line235_indent_first, line235_indent_next, line235_elements},
    {line236_indent_first, line236_indent_next, line236_elements},
    {line237_indent_first, line237_indent_next, line237_elements},
    {line238_indent_first, line238_indent_next, line238_elements},
    {line239_indent_first, line239_indent_next, line239_elements},
    {line240_indent_first, line240_indent_next, line240_elements},
    {line241_indent_first, line241_indent_next, line241_elements},
    {line242_indent_first, line242_indent_next, line242_elements},
    {line243_indent_first, line243_indent_next, line243_elements},
    {line244_indent_first, line244_indent_next, line244_elements},
    {line245_indent_first, line245_indent_next, line245_elements},
    {line246_indent_first, line246_indent_next, line246_elements},
    {line247_indent_first, line247_indent_next, line247_elements},
    {line248_indent_first, line248_indent_next, line248_elements},
    {line249_indent_first, line249_indent_next, line249_elements},
    {line250_indent_first, line250_indent_next, line250_elements},
    {line251_indent_first, line251_indent_next, line251_elements},
    {line252_indent_first, line252_indent_next, line252_elements},
    {line253_indent_first, line253_indent_next, line253_elements},
    {line254_indent_first, line254_indent_next, line254_elements},
    {line255_indent_first, line255_indent_next, line255_elements},
    {line256_indent_first, line256_indent_next, line256_elements},
    {line257_indent_first, line257_indent_next, line257_elements},
    {line258_indent_first, line258_indent_next, line258_elements},
    {line259_indent_first, line259_indent_next, line259_elements},
    {line260_indent_first, line260_indent_next, line260_elements},
    {line261_indent_first, line261_indent_next, line261_elements},
    {line262_indent_first, line262_indent_next, line262_elements},
    {line263_indent_first, line263_indent_next, line263_elements},
    {line264_indent_first, line264_indent_next, line264_elements},
    {line265_indent_first, line265_indent_next, line265_elements},
    {line266_indent_first, line266_indent_next, line266_elements},
    {line267_indent_first, line267_indent_next, line267_elements},
    {line268_indent_first, line268_indent_next, line268_elements},
    {line269_indent_first, line269_indent_next, line269_elements},
    {line270_indent_first, line270_indent_next, line270_elements},
    {line271_indent_first, line271_indent_next, line271_elements},
    {line272_indent_first, line272_indent_next, line272_elements},
    {line273_indent_first, line273_indent_next, line273_elements},
    {line274_indent_first, line274_indent_next, line274_elements},
    {line275_indent_first, line275_indent_next, line275_elements},
    {line276_indent_first, line276_indent_next, line276_elements},
    {line277_indent_first, line277_indent_next, line277_elements},
    {line278_indent_first, line278_indent_next, line278_elements},
    {line279_indent_first, line279_indent_next, line279_elements},
    {line280_indent_first, line280_indent_next, line280_elements},
    {line281_indent_first, line281_indent_next, line281_elements},
    {line282_indent_first, line282_indent_next, line282_elements},
    {line283_indent_first, line283_indent_next, line283_elements},
    {line284_indent_first, line284_indent_next, line284_elements},
    {line285_indent_first, line285_indent_next, line285_elements},
    {line286_indent_first, line286_indent_next, line286_elements},
    {line287_indent_first, line287_indent_next, line287_elements},
    {line288_indent_first, line288_indent_next, line288_elements},
    {line289_indent_first, line289_indent_next, line289_elements},
    {line290_indent_first, line290_indent_next, line290_elements},
    {line291_indent_first, line291_indent_next, line291_elements},
    {line292_indent_first, line292_indent_next, line292_elements},
    {line293_indent_first, line293_indent_next, line293_elements},
    {line294_indent_first, line294_indent_next, line294_elements},
    {line295_indent_first, line295_indent_next, line295_elements},
    {line296_indent_first, line296_indent_next, line296_elements},
    {line297_indent_first, line297_indent_next, line297_elements},
    {line298_indent_first, line298_indent_next, line298_elements},
    {line299_indent_first, line299_indent_next, line299_elements},
    {line300_indent_first, line300_indent_next, line300_elements},
    {line301_indent_first, line301_indent_next, line301_elements},
    {line302_indent_first, line302_indent_next, line302_elements},
    {line303_indent_first, line303_indent_next, line303_elements},
    {line304_indent_first, line304_indent_next, line304_elements},
    {line305_indent_first, line305_indent_next, line305_elements},
    {line306_indent_first, line306_indent_next, line306_elements},
    {line307_indent_first, line307_indent_next, line307_elements},
    {line308_indent_first, line308_indent_next, line308_elements},
    {line309_indent_first, line309_indent_next, line309_elements},
    {line310_indent_first, line310_indent_next, line310_elements},
    {line311_indent_first, line311_indent_next, line311_elements},
    {line312_indent_first, line312_indent_next, line312_elements},
    {line313_indent_first, line313_indent_next, line313_elements},
    {line314_indent_first, line314_indent_next, line314_elements},
    {line315_indent_first, line315_indent_next, line315_elements},
    {line316_indent_first, line316_indent_next, line316_elements},
    {line317_indent_first, line317_indent_next, line317_elements},
    {line318_indent_first, line318_indent_next, line318_elements},
    {line319_indent_first, line319_indent_next, line319_elements},
    {line320_indent_first, line320_indent_next, line320_elements},
    {line321_indent_first, line321_indent_next, line321_elements},
    {line322_indent_first, line322_indent_next, line322_elements},
    {line323_indent_first, line323_indent_next, line323_elements},
    {line324_indent_first, line324_indent_next, line324_elements},
    {line325_indent_first, line325_indent_next, line325_elements},
    {line326_indent_first, line326_indent_next, line326_elements},
    {line327_indent_first, line327_indent_next, line327_elements},
    {line328_indent_first, line328_indent_next, line328_elements},
    {line329_indent_first, line329_indent_next, line329_elements},
    {line330_indent_first, line330_indent_next, line330_elements},
    {line331_indent_first, line331_indent_next, line331_elements},
    {line332_indent_first, line332_indent_next, line332_elements},
    {line333_indent_first, line333_indent_next, line333_elements},
    {line334_indent_first, line334_indent_next, line334_elements},
    {line335_indent_first, line335_indent_next, line335_elements},
    {line336_indent_first, line336_indent_next, line336_elements},
    {line337_indent_first, line337_indent_next, line337_elements},
    {line338_indent_first, line338_indent_next, line338_elements},
    {line339_indent_first, line339_indent_next, line339_elements},
    {line340_indent_first, line340_indent_next, line340_elements},
    {line341_indent_first, line341_indent_next, line341_elements},
    {line342_indent_first, line342_indent_next, line342_elements},
    {line343_indent_first, line343_indent_next, line343_elements},
    {line344_indent_first, line344_indent_next, line344_elements},
    {line345_indent_first, line345_indent_next, line345_elements},
    {line346_indent_first, line346_indent_next, line346_elements},
    {line347_indent_first, line347_indent_next, line347_elements},
    {line348_indent_first, line348_indent_next, line348_elements},
    {line349_indent_first, line349_indent_next, line349_elements},
    {line350_indent_first, line350_indent_next, line350_elements},
    {line351_indent_first, line351_indent_next, line351_elements},
    {line352_indent_first, line352_indent_next, line352_elements},
    {line353_indent_first, line353_indent_next, line353_elements},
    {line354_indent_first, line354_indent_next, line354_elements},
    {line355_indent_first, line355_indent_next, line355_elements},
    {line356_indent_first, line356_indent_next, line356_elements},
    {line357_indent_first, line357_indent_next, line357_elements},
    {line358_indent_first, line358_indent_next, line358_elements},
    {line359_indent_first, line359_indent_next, line359_elements},
    {line360_indent_first, line360_indent_next, line360_elements},
    {line361_indent_first, line361_indent_next, line361_elements},
    {line362_indent_first, line362_indent_next, line362_elements},
    {line363_indent_first, line363_indent_next, line363_elements},
    {line364_indent_first, line364_indent_next, line364_elements},
    {line365_indent_first, line365_indent_next, line365_elements},
    {line366_indent_first, line366_indent_next, line366_elements},
    {line367_indent_first, line367_indent_next, line367_elements},
    {line368_indent_first, line368_indent_next, line368_elements},
    {line369_indent_first, line369_indent_next, line369_elements},
    {line370_indent_first, line370_indent_next, line370_elements},
    {line371_indent_first, line371_indent_next, line371_elements},
    {line372_indent_first, line372_indent_next, line372_elements},
    {line373_indent_first, line373_indent_next, line373_elements},
    {line374_indent_first, line374_indent_next, line374_elements},
    {line375_indent_first, line375_indent_next, line375_elements},
    {line376_indent_first, line376_indent_next, line376_elements},
    {line377_indent_first, line377_indent_next, line377_elements},
    {line378_indent_first, line378_indent_next, line378_elements},
    {line379_indent_first, line379_indent_next, line379_elements},
    {line380_indent_first, line380_indent_next, line380_elements},
    {line381_indent_first, line381_indent_next, line381_elements},
    {line382_indent_first, line382_indent_next, line382_elements},
    {line383_indent_first, line383_indent_next, line383_elements},
    {line384_indent_first, line384_indent_next, line384_elements},
    {line385_indent_first, line385_indent_next, line385_elements},
    {line386_indent_first, line386_indent_next, line386_elements},
    {line387_indent_first, line387_indent_next, line387_elements},
    {line388_indent_first, line388_indent_next, line388_elements},
    {line389_indent_first, line389_indent_next, line389_elements},
    {line390_indent_first, line390_indent_next, line390_elements},
    {line391_indent_first, line391_indent_next, line391_elements},
    {line392_indent_first, line392_indent_next, line392_elements},
    {line393_indent_first, line393_indent_next, line393_elements},
    {line394_indent_first, line394_indent_next, line394_elements},
    {line395_indent_first, line395_indent_next, line395_elements},
    {line396_indent_first, line396_indent_next, line396_elements},
    {line397_indent_first, line397_indent_next, line397_elements},
    {line398_indent_first, line398_indent_next, line398_elements},
    {line399_indent_first, line399_indent_next, line399_elements},
    {line400_indent_first, line400_indent_next, line400_elements},
    {line401_indent_first, line401_indent_next, line401_elements},
    {line402_indent_first, line402_indent_next, line402_elements},
    {line403_indent_first, line403_indent_next, line403_elements},
    {line404_indent_first, line404_indent_next, line404_elements},
    {line405_indent_first, line405_indent_next, line405_elements},
    {line406_indent_first, line406_indent_next, line406_elements},
    {line407_indent_first, line407_indent_next, line407_elements},
    {line408_indent_first, line408_indent_next, line408_elements},
    {line409_indent_first, line409_indent_next, line409_elements},
    {line410_indent_first, line410_indent_next, line410_elements},
    {line411_indent_first, line411_indent_next, line411_elements},
    {line412_indent_first, line412_indent_next, line412_elements},
    {line413_indent_first, line413_indent_next, line413_elements},
    {line414_indent_first, line414_indent_next, line414_elements},
    {line415_indent_first, line415_indent_next, line415_elements},
    {line416_indent_first, line416_indent_next, line416_elements},
    {line417_indent_first, line417_indent_next, line417_elements},
    {line418_indent_first, line418_indent_next, line418_elements},
    {line419_indent_first, line419_indent_next, line419_elements},
    {line420_indent_first, line420_indent_next, line420_elements},
    {line421_indent_first, line421_indent_next, line421_elements},
    {line422_indent_first, line422_indent_next, line422_elements},
    {line423_indent_first, line423_indent_next, line423_elements},
    {line424_indent_first, line424_indent_next, line424_elements},
    {line425_indent_first, line425_indent_next, line425_elements},
    {line426_indent_first, line426_indent_next, line426_elements},
    {line427_indent_first, line427_indent_next, line427_elements},
    {line428_indent_first, line428_indent_next, line428_elements},
    {line429_indent_first, line429_indent_next, line429_elements},
    {line430_indent_first, line430_indent_next, line430_elements},
}};
} // namespace

// NOLINTEND(readability-*)

document get_mkdwarfs_manpage() { return document_array; }

} // namespace dwarfs::tool::manpage
