diff --git a/build.zig b/build.zig
new file mode 100644
index 0000000..813d69f
--- /dev/null
+++ b/build.zig
@@ -0,0 +1,44 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "ziglue",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    b.installArtifact(exe);
+
+    const run_cmd = b.addRunArtifact(exe);
+
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    const example_tests = b.addTest(.{
+        .root_source_file = b.path("src/examples.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_exe_unit_tests.step);
+    test_step.dependOn(&example_tests.step);
+}
diff --git a/build.zig.zon b/build.zig.zon
new file mode 100644
index 0000000..23fe8b7
--- /dev/null
+++ b/build.zig.zon
@@ -0,0 +1,10 @@
+.{
+    .name = "ziglue",
+    .version = "0.0.0",
+
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+    },
+}
diff --git a/examples.py b/examples.py
new file mode 100644
index 0000000..728439f
--- /dev/null
+++ b/examples.py
@@ -0,0 +1,52 @@
+import parsel
+import httpx
+from pathlib import Path
+from textwrap import indent
+
+VERSION = '0.31.2'
+
+CACHE = Path('.spec', VERSION)
+URL = f'https://spec.commonmark.org/{VERSION}/'
+
+if CACHE.exists():
+    sel = parsel.Selector(CACHE.read_text())
+else:
+    response = httpx.get('https://spec.commonmark.org/0.31.2/')
+    response.raise_for_status()
+    CACHE.parent.mkdir(parents=True, exist_ok=True)
+    CACHE.write_text(response.text)
+    sel = parsel.Selector(response.text)
+
+print(
+'''const std = @import("std");
+const convert = @import("main.zig").convert;
+'''
+)
+
+for example in sel.css('.example'):
+    name = example.css('.examplenum > a::text').get()
+    md = example.css('.language-markdown::text').get()
+    html = example.css('.language-html::text').get()
+
+    assert name is not None
+
+    print(f'''
+test "{name}" {{
+    const alloc = std.testing.allocator;
+
+    const md = (
+{indent(md, r'        \\', lambda _: True) if md else '""'}
+);
+    const html = (
+{indent(html, r'        \\', lambda _: True) if html else '""'}
+);
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}}
+''')
+
+    # mdtext = textwrap.indent("md", '\\')
+
diff --git a/notes.md b/notes.md
new file mode 100644
index 0000000..89a6f8a
--- /dev/null
+++ b/notes.md
@@ -0,0 +1,35 @@
+The spec is organized into "content blocks", "leaf blocks", and inline content. I should take this as a hint to do the same.
+
+So the first task in the parser should be to parse the block structure.
+
+- Blocks
+  - Leaf
+    - Thematic break
+    - ATX heading
+    - Setext heading
+    - Indented chunk
+      + Indented code block is a sequence of indented chunks.
+      + Preserve count of blank lines.
+    - Fenced code block
+    - HTML blocks
+    - Link reference definition
+    - Paragraph
+    - Blank lines
+      + These are part of the document, but they are not rendered.
+  - Container
+    - Blockquote
+    - List Item
+      + List is a sequence of list items of the same type.
+
+- Inline
+  - Inline code
+  - Strong, emph
+  - Links
+    - Inline
+    - Reference
+    - Images
+    - Auto
+  - HTML
+  - Text
+
+<!--vim: ts=2 sw=2 et linebreak :-->
diff --git a/src/examples.zig b/src/examples.zig
new file mode 100644
index 0000000..9fdfbdf
--- /dev/null
+++ b/src/examples.zig
@@ -0,0 +1,11414 @@
+const std = @import("std");
+const convert = @import("main.zig").convert;
+
+comptime {
+    std.testing.refAllDecls(@This());
+}
+
+test "Example 1" {
+    return error.BBBBBBBBBBBBb;
+}
+
+test "Example 2" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\→foo→baz→→bim
+    );
+    const html = (
+        \\<pre><code>foo→baz→→bim
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 3" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a→a
+    );
+    const html = (
+        \\<pre><code>a→a
+        \\ὐ→a
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 4" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<p>bar</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 5" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 6" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>→→foo
+    );
+    const html = (
+        \\<blockquote>
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 7" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-→→foo
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 8" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\→bar
+    );
+    const html = (
+        \\<pre><code>foo
+        \\bar
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 9" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo
+        \\<ul>
+        \\<li>bar
+        \\<ul>
+        \\<li>baz</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 10" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#→Foo
+    );
+    const html = (
+        \\<h1>Foo</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 11" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*→*→*→
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 12" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~
+    );
+    const html = (
+        \\<p>!&quot;#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{|}~</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 13" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\→\A\a\
+    );
+    const html = (
+        \\<p>\→\A\a\
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 14" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\*not
+    );
+    const html = (
+        \\<p>*not
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 15" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\\*emphasis*
+    );
+    const html = (
+        \\<p>\<em>emphasis</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 16" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo\
+        \\bar
+    );
+    const html = (
+        \\<p>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 17" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\``
+    );
+    const html = (
+        \\<p><code>\[\`</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 18" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\[\]
+    );
+    const html = (
+        \\<pre><code>\[\]
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 19" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~
+        \\\[\]
+        \\~~~
+    );
+    const html = (
+        \\<pre><code>\[\]
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 20" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<https://example.com?find=\*>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 21" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 22" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo](/bar\*
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 23" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 24" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<pre><code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 25" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&nbsp;
+    );
+    const html = (
+        \\<p> 
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 26" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&#35;
+    );
+    const html = (
+        \\<p>#
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 27" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&#X22;
+    );
+    const html = (
+        \\<p>&quot;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 28" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&nbsp
+    );
+    const html = (
+        \\<p>&amp;nbsp
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 29" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&copy
+    );
+    const html = (
+        \\<p>&amp;copy</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 30" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&MadeUpEntity;
+    );
+    const html = (
+        \\<p>&amp;MadeUpEntity;</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 31" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 32" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo](/f&ouml;&ouml;
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 33" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 34" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<pre><code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 35" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`f&ouml;&ouml;`
+    );
+    const html = (
+        \\<p><code>f&amp;ouml;&amp;ouml;</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 36" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\f&ouml;f&ouml;
+    );
+    const html = (
+        \\<pre><code>f&amp;ouml;f&amp;ouml;
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 37" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&#42;foo&#42;
+        \\*foo*
+    );
+    const html = (
+        \\<p>*foo*
+        \\<em>foo</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 38" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&#42;
+    );
+    const html = (
+        \\<p>*
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 39" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo&#10;&#10;bar
+    );
+    const html = (
+        \\<p>foo
+        \\
+        \\bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 40" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\&#9;foo
+    );
+    const html = (
+        \\<p>→foo</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 41" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[a](url
+    );
+    const html = (
+        \\<p>[a](url
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 42" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>`one</li>
+        \\<li>two`</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 43" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***
+        \\---
+        \\___
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 44" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\+++
+    );
+    const html = (
+        \\<p>+++</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 45" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\===
+    );
+    const html = (
+        \\<p>===</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 46" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\--
+        \\**
+        \\__
+    );
+    const html = (
+        \\<p>--
+        \\**
+        \\__</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 47" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 48" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***
+    );
+    const html = (
+        \\<pre><code>***
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 49" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<p>Foo
+        \\***</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 50" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_____________________________________
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 51" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 52" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 53" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 54" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 55" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_
+    );
+    const html = (
+        \\<p>_
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 56" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*-*
+    );
+    const html = (
+        \\<p><em>-</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 57" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\</ul>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 58" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\***
+        \\bar
+    );
+    const html = (
+        \\<p>Foo</p>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 59" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\---
+        \\bar
+    );
+    const html = (
+        \\<h2>Foo</h2>
+        \\<p>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 60" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*
+    );
+    const html = (
+        \\<ul>
+        \\<li>Foo</li>
+        \\</ul>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 61" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>Foo</li>
+        \\<li>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 62" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1>foo</h1>
+        \\<h2>foo</h2>
+        \\<h3>foo</h3>
+        \\<h4>foo</h4>
+        \\<h5>foo</h5>
+        \\<h6>foo</h6>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 63" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#######
+    );
+    const html = (
+        \\<p>#######
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 64" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#5
+    );
+    const html = (
+        \\<p>#5
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 65" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\##
+    );
+    const html = (
+        \\<p>##
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 66" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 67" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1>foo</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 68" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\###
+    );
+    const html = (
+        \\<h3>foo</h3>
+        \\<h2>foo</h2>
+        \\<h1>foo</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 69" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<pre><code>#
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 70" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+        \\#
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 71" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\##
+    );
+    const html = (
+        \\<h2>foo</h2>
+        \\<h3>bar</h3>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 72" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1>foo</h1>
+        \\<h5>foo</h5>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 73" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\###
+    );
+    const html = (
+        \\<h3>foo</h3>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 74" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\###
+    );
+    const html = (
+        \\<h3>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 75" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1>foo#</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 76" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\###
+    );
+    const html = (
+        \\<h3>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 77" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\****
+        \\##
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 78" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<p>Foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 79" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\##
+    );
+    const html = (
+        \\<h2></h2>
+        \\<h1></h1>
+        \\<h3></h3>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 80" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<h1>Foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 81" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<h1>Foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 82" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<h1>Foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 83" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\-------------------------
+        \\
+        \\Foo
+        \\=
+    );
+    const html = (
+        \\<h2>Foo</h2>
+        \\<h1>Foo</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 84" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\---
+        \\
+    );
+    const html = (
+        \\<h2>Foo</h2>
+        \\<h2>Foo</h2>
+        \\<h1>Foo</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 85" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<pre><code>Foo
+        \\---
+        \\
+        \\Foo
+        \\</code></pre>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 86" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<h2>Foo</h2>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 87" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<p>Foo
+        \\---</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 88" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\=
+    );
+    const html = (
+        \\<p>Foo
+        \\=
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 89" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<h2>Foo</h2>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 90" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo\
+        \\----
+    );
+    const html = (
+        \\<h2>Foo\</h2>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 91" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`Foo
+        \\----
+        \\`
+        \\
+        \\<a
+    );
+    const html = (
+        \\<h2>`Foo</h2>
+        \\<p>`</p>
+        \\<h2>&lt;a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 92" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>Foo</p>
+        \\</blockquote>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 93" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo
+        \\bar
+        \\===</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 94" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>Foo</li>
+        \\</ul>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 95" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\Bar
+        \\---
+    );
+    const html = (
+        \\<h2>Foo
+        \\Bar</h2>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 96" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\---
+        \\Foo
+        \\---
+        \\Bar
+        \\---
+        \\Baz
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 97" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\
+        \\====
+    );
+    const html = (
+        \\<p>====</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 98" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\---
+        \\---
+    );
+    const html = (
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 99" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\</ul>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 100" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\---
+    );
+    const html = (
+        \\<pre><code>foo
+        \\</code></pre>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 101" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo</p>
+        \\</blockquote>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 102" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\>
+    );
+    const html = (
+        \\<h2>&gt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 103" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\
+        \\bar
+        \\---
+        \\baz
+    );
+    const html = (
+        \\<p>Foo</p>
+        \\<h2>bar</h2>
+        \\<p>baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 104" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\bar
+        \\
+        \\---
+        \\
+        \\baz
+    );
+    const html = (
+        \\<p>Foo
+        \\bar</p>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 105" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\bar
+        \\*
+    );
+    const html = (
+        \\<p>Foo
+        \\bar</p>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 106" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\bar
+        \\\---
+        \\baz
+    );
+    const html = (
+        \\<p>Foo
+        \\bar
+        \\---
+        \\baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 107" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a
+    );
+    const html = (
+        \\<pre><code>a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 108" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<p>bar</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 109" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>foo</p>
+        \\<ul>
+        \\<li>bar</li>
+        \\</ul>
+        \\</li>
+        \\</ol>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 110" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a/>
+    );
+    const html = (
+        \\<pre><code>&lt;a/&gt;
+        \\*hi*
+        \\
+        \\-
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 111" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\chunk1
+        \\
+    );
+    const html = (
+        \\<pre><code>chunk1
+        \\
+        \\chunk2
+        \\
+        \\
+        \\
+        \\chunk3
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 112" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\chunk1
+    );
+    const html = (
+        \\<pre><code>chunk1
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 113" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<p>Foo
+        \\bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 114" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\bar
+    );
+    const html = (
+        \\<pre><code>foo
+        \\</code></pre>
+        \\<p>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 115" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1>Heading</h1>
+        \\<pre><code>foo
+        \\</code></pre>
+        \\<h2>Heading</h2>
+        \\<pre><code>foo
+        \\</code></pre>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 116" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 117" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\
+    );
+    const html = (
+        \\<pre><code>foo
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 118" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<pre><code>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 119" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\<
+    );
+    const html = (
+        \\<pre><code>&lt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 120" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~
+        \\<
+    );
+    const html = (
+        \\<pre><code>&lt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 121" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\``
+        \\foo
+        \\``
+    );
+    const html = (
+        \\<p><code>foo</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 122" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\aaa
+        \\~~~
+        \\```
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\~~~
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 123" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~
+        \\aaa
+        \\```
+        \\~~~
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\```
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 124" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\````
+        \\aaa
+        \\```
+        \\``````
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\```
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 125" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~~
+        \\aaa
+        \\~~~
+        \\~~~~
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\~~~
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 126" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<pre><code></code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 127" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`````
+        \\
+        \\```
+        \\aaa
+    );
+    const html = (
+        \\<pre><code>
+        \\```
+        \\aaa
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 128" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<pre><code>aaa
+        \\</code></pre>
+        \\</blockquote>
+        \\<p>bbb</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 129" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\
+    );
+    const html = (
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 130" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\```
+    );
+    const html = (
+        \\<pre><code></code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 131" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\aaa
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 132" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\aaa
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\aaa
+        \\aaa
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 133" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<pre><code>aaa
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 134" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<pre><code>```
+        \\aaa
+        \\```
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 135" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\aaa
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 136" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\aaa
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 137" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\aaa
+    );
+    const html = (
+        \\<pre><code>aaa
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 138" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<p><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 139" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~~~~
+        \\aaa
+        \\~~~
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\~~~
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 140" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\```
+        \\bar
+        \\```
+        \\baz
+    );
+    const html = (
+        \\<p>foo</p>
+        \\<pre><code>bar
+        \\</code></pre>
+        \\<p>baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 141" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\---
+        \\~~~
+        \\bar
+        \\~~~
+        \\#
+    );
+    const html = (
+        \\<h2>foo</h2>
+        \\<pre><code>bar
+        \\</code></pre>
+        \\<h1>baz</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 142" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```ruby
+        \\def
+    );
+    const html = (
+        \\<pre><code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 143" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~~
+    );
+    const html = (
+        \\<pre><code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 144" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\````;
+        \\````
+    );
+    const html = (
+        \\<pre><code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 145" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+    );
+    const html = (
+        \\<p><code>aa</code>
+        \\foo</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 146" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\~~~
+    );
+    const html = (
+        \\<pre><code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 147" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\```
+    );
+    const html = (
+        \\<pre><code>```
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 148" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<table><tr><td>
+        \\<pre>
+        \\**Hello**,
+        \\
+        \\_world_.
+        \\</pre>
+        \\</td></tr></table>
+    );
+    const html = (
+        \\<table><tr><td>
+        \\<pre>
+        \\**Hello**,
+        \\<p><em>world</em>.
+        \\</pre></p>
+        \\</td></tr></table>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 149" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<table>
+    );
+    const html = (
+        \\<table>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 150" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div>
+    );
+    const html = (
+        \\<div>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 151" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\</div>
+        \\*foo*
+    );
+    const html = (
+        \\</div>
+        \\*foo*
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 152" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<DIV
+    );
+    const html = (
+        \\<DIV
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 153" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div
+    );
+    const html = (
+        \\<div
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 154" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div
+    );
+    const html = (
+        \\<div
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 155" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div>
+        \\*foo*
+        \\
+        \\*bar*
+    );
+    const html = (
+        \\<div>
+        \\*foo*
+        \\<p><em>bar</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 156" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div
+    );
+    const html = (
+        \\<div
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 157" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div
+    );
+    const html = (
+        \\<div
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 158" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div
+    );
+    const html = (
+        \\<div
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 159" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div><a
+    );
+    const html = (
+        \\<div><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 160" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<table><tr><td>
+        \\foo
+        \\</td></tr></table>
+    );
+    const html = (
+        \\<table><tr><td>
+        \\foo
+        \\</td></tr></table>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 161" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div></div>
+        \\```
+    );
+    const html = (
+        \\<div></div>
+        \\```
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 162" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 163" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<Warning>
+        \\*bar*
+        \\</Warning>
+    );
+    const html = (
+        \\<Warning>
+        \\*bar*
+        \\</Warning>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 164" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<i
+    );
+    const html = (
+        \\<i
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 165" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\</ins>
+        \\*bar*
+    );
+    const html = (
+        \\</ins>
+        \\*bar*
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 166" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<del>
+        \\*foo*
+        \\</del>
+    );
+    const html = (
+        \\<del>
+        \\*foo*
+        \\</del>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 167" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<del>
+        \\
+        \\*foo*
+        \\
+        \\</del>
+    );
+    const html = (
+        \\<del>
+        \\<p><em>foo</em></p>
+        \\</del>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 168" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<del>*foo*</del>
+    );
+    const html = (
+        \\<p><del><em>foo</em></del></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 169" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<pre
+    );
+    const html = (
+        \\<pre
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 170" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<script
+    );
+    const html = (
+        \\<script
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 171" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<textarea>
+        \\
+        \\*foo*
+        \\
+        \\_bar_
+        \\
+        \\</textarea>
+    );
+    const html = (
+        \\<textarea>
+        \\
+        \\*foo*
+        \\
+        \\_bar_
+        \\
+        \\</textarea>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 172" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<style
+    );
+    const html = (
+        \\<style
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 173" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<style
+    );
+    const html = (
+        \\<style
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 174" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<div>
+        \\foo
+        \\</blockquote>
+        \\<p>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 175" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<div>
+        \\</li>
+        \\<li>foo</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 176" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<style>p{color:red;}</style>
+        \\*foo*
+    );
+    const html = (
+        \\<style>p{color:red;}</style>
+        \\<p><em>foo</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 177" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<!--
+    );
+    const html = (
+        \\<!--
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 178" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<script>
+        \\foo
+        \\</script>1.
+    );
+    const html = (
+        \\<script>
+        \\foo
+        \\</script>1.
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 179" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<!--
+    );
+    const html = (
+        \\<!--
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 180" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<?php
+        \\
+    );
+    const html = (
+        \\<?php
+        \\
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 181" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<!DOCTYPE
+    );
+    const html = (
+        \\<!DOCTYPE
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 182" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<![CDATA[
+        \\function
+    );
+    const html = (
+        \\<![CDATA[
+        \\function
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 183" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<!--
+    );
+    const html = (
+        \\<!--
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 184" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div>
+        \\
+    );
+    const html = (
+        \\<div>
+        \\<pre><code>&lt;div&gt;
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 185" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\<div>
+        \\bar
+        \\</div>
+    );
+    const html = (
+        \\<p>Foo</p>
+        \\<div>
+        \\bar
+        \\</div>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 186" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div>
+        \\bar
+        \\</div>
+        \\*foo*
+    );
+    const html = (
+        \\<div>
+        \\bar
+        \\</div>
+        \\*foo*
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 187" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\<a
+    );
+    const html = (
+        \\<p>Foo
+        \\<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 188" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div>
+        \\
+        \\*Emphasized*
+    );
+    const html = (
+        \\<div>
+        \\<p><em>Emphasized</em>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 189" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<div>
+        \\*Emphasized*
+    );
+    const html = (
+        \\<div>
+        \\*Emphasized*
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 190" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<table>
+        \\
+        \\<tr>
+        \\
+        \\<td>
+        \\Hi
+        \\</td>
+        \\
+        \\</tr>
+        \\
+        \\</table>
+    );
+    const html = (
+        \\<table>
+        \\<tr>
+        \\<td>
+        \\Hi
+        \\</td>
+        \\</tr>
+        \\</table>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 191" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<table>
+        \\
+    );
+    const html = (
+        \\<table>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 192" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 193" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 194" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[Foo*bar\]]:my_(url)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 195" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[Foo
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 196" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 197" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p>[foo]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 198" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+        \\/url
+        \\
+        \\[foo]
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 199" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+        \\
+        \\[foo]
+    );
+    const html = (
+        \\<p>[foo]:</p>
+        \\<p>[foo]</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 200" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 201" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p>[foo]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 202" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 203" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 204" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 205" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[FOO]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 206" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[ΑΓΩ]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 207" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = ("");
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 208" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[
+        \\foo
+        \\]:
+    );
+    const html = (
+        \\<p>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 209" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p>[foo]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 210" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p>&quot;title&quot;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 211" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<pre><code>[foo]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 212" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```
+        \\[foo]:
+    );
+    const html = (
+        \\<pre><code>[foo]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 213" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\[bar]:
+    );
+    const html = (
+        \\<p>Foo
+        \\[bar]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 214" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\#
+    );
+    const html = (
+        \\<h1><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 215" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<h1>bar</h1>
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 216" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p>===
+        \\<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 217" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 218" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\
+        \\>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 219" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+        \\
+        \\bbb
+    );
+    const html = (
+        \\<p>aaa</p>
+        \\<p>bbb</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 220" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+        \\bbb
+        \\
+        \\ccc
+        \\ddd
+    );
+    const html = (
+        \\<p>aaa
+        \\bbb</p>
+        \\<p>ccc
+        \\ddd</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 221" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+        \\
+        \\
+        \\bbb
+    );
+    const html = (
+        \\<p>aaa</p>
+        \\<p>bbb</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 222" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+    );
+    const html = (
+        \\<p>aaa
+        \\bbb</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 223" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+    );
+    const html = (
+        \\<p>aaa
+        \\bbb
+        \\ccc</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 224" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+        \\bbb
+    );
+    const html = (
+        \\<p>aaa
+        \\bbb</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 225" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+        \\bbb
+    );
+    const html = (
+        \\<pre><code>aaa
+        \\</code></pre>
+        \\<p>bbb</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 226" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aaa
+    );
+    const html = (
+        \\<p>aaa<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 227" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\
+        \\
+        \\aaa
+    );
+    const html = (
+        \\<p>aaa</p>
+        \\<h1>aaa</h1>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 228" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<h1>Foo</h1>
+        \\<p>bar
+        \\baz</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 229" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>#
+    );
+    const html = (
+        \\<blockquote>
+        \\<h1>Foo</h1>
+        \\<p>bar
+        \\baz</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 230" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<h1>Foo</h1>
+        \\<p>bar
+        \\baz</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 231" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<pre><code>&gt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 232" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<h1>Foo</h1>
+        \\<p>bar
+        \\baz</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 233" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>bar
+        \\baz
+        \\foo</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 234" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo</p>
+        \\</blockquote>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 235" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<ul>
+        \\<li>foo</li>
+        \\</ul>
+        \\</blockquote>
+        \\<ul>
+        \\<li>bar</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 236" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<pre><code>foo
+        \\</code></pre>
+        \\</blockquote>
+        \\<pre><code>bar
+        \\</code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 237" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<pre><code></code></pre>
+        \\</blockquote>
+        \\<p>foo</p>
+        \\<pre><code></code></pre>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 238" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo
+        \\-
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 239" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 240" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 241" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 242" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo</p>
+        \\</blockquote>
+        \\<blockquote>
+        \\<p>bar</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 243" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo
+        \\bar</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 244" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>foo</p>
+        \\<p>bar</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 245" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\>
+    );
+    const html = (
+        \\<p>foo</p>
+        \\<blockquote>
+        \\<p>bar</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 246" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>aaa</p>
+        \\</blockquote>
+        \\<hr
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 247" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>bar
+        \\baz</p>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 248" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>bar</p>
+        \\</blockquote>
+        \\<p>baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 249" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<p>bar</p>
+        \\</blockquote>
+        \\<p>baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 250" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<blockquote>
+        \\<blockquote>
+        \\<p>foo
+        \\bar</p>
+        \\</blockquote>
+        \\</blockquote>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 251" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>>>
+    );
+    const html = (
+        \\<blockquote>
+        \\<blockquote>
+        \\<blockquote>
+        \\<p>foo
+        \\bar
+        \\baz</p>
+        \\</blockquote>
+        \\</blockquote>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 252" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<pre><code>code
+        \\</code></pre>
+        \\</blockquote>
+        \\<blockquote>
+        \\<p>not
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 253" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\A
+    );
+    const html = (
+        \\<p>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 254" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 255" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>one</li>
+        \\</ul>
+        \\<p>two</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 256" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>one</p>
+        \\<p>two</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 257" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>one</li>
+        \\</ul>
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 258" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>one</p>
+        \\<p>two</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 259" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<blockquote>
+        \\<ol>
+        \\<li>
+        \\<p>one</p>
+        \\<p>two</p>
+        \\</li>
+        \\</ol>
+        \\</blockquote>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 260" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>>-
+    );
+    const html = (
+        \\<blockquote>
+        \\<blockquote>
+        \\<ul>
+        \\<li>one</li>
+        \\</ul>
+        \\<p>two</p>
+        \\</blockquote>
+        \\</blockquote>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 261" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-one
+        \\
+        \\2.two
+    );
+    const html = (
+        \\<p>-one</p>
+        \\<p>2.two</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 262" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<p>bar</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 263" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>foo</p>
+        \\<pre><code>bar
+        \\</code></pre>
+        \\<p>baz</p>
+        \\<blockquote>
+        \\<p>bam</p>
+        \\</blockquote>
+        \\</li>
+        \\</ol>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 264" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>Foo</p>
+        \\<pre><code>bar
+        \\
+        \\
+        \\baz
+        \\</code></pre>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 265" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\123456789.
+    );
+    const html = (
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 266" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1234567890.
+    );
+    const html = (
+        \\<p>1234567890.
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 267" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\0.
+    );
+    const html = (
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 268" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\003.
+    );
+    const html = (
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 269" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-1.
+    );
+    const html = (
+        \\<p>-1.
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 270" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<pre><code>bar
+        \\</code></pre>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 271" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\10.
+    );
+    const html = (
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 272" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\indented
+    );
+    const html = (
+        \\<pre><code>indented
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 273" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<pre><code>indented
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 274" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<pre><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 275" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\
+        \\bar
+    );
+    const html = (
+        \\<p>foo</p>
+        \\<p>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 276" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\</ul>
+        \\<p>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 277" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<p>bar</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 278" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\<li>
+        \\<pre><code>bar
+        \\</code></pre>
+        \\</li>
+        \\<li>
+        \\<pre><code>baz
+        \\</code></pre>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 279" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 280" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+        \\
+    );
+    const html = (
+        \\<ul>
+        \\<li></li>
+        \\</ul>
+        \\<p>foo</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 281" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\<li></li>
+        \\<li>bar</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 282" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\<li></li>
+        \\<li>bar</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 283" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>foo</li>
+        \\<li></li>
+        \\<li>bar</li>
+        \\</ol>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 284" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*
+    );
+    const html = (
+        \\<ul>
+        \\<li></li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 285" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\*
+        \\
+        \\foo
+        \\1.
+    );
+    const html = (
+        \\<p>foo
+        \\*</p>
+        \\<p>foo
+        \\1.</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 286" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 287" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 288" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 289" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<pre><code>1.
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 290" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 291" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>A
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 292" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<ol>
+        \\<li>
+        \\<blockquote>
+        \\<p>Blockquote
+        \\continued
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 293" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\>
+    );
+    const html = (
+        \\<blockquote>
+        \\<ol>
+        \\<li>
+        \\<blockquote>
+        \\<p>Blockquote
+        \\continued
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 294" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo
+        \\<ul>
+        \\<li>bar
+        \\<ul>
+        \\<li>baz
+        \\<ul>
+        \\<li>boo</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 295" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\<li>bar</li>
+        \\<li>baz</li>
+        \\<li>boo</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 296" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\10)
+    );
+    const html = (
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 297" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\10)
+    );
+    const html = (
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 298" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<ul>
+        \\<li>foo</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 299" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<ul>
+        \\<li>
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 300" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<h1>Foo</h1>
+        \\</li>
+        \\<li>
+        \\<h2>Bar</h2>
+        \\baz</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 301" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\<li>bar</li>
+        \\</ul>
+        \\<ul>
+        \\<li>baz</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 302" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>foo</li>
+        \\<li>bar</li>
+        \\</ol>
+        \\<ol
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 303" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+        \\-
+    );
+    const html = (
+        \\<p>Foo</p>
+        \\<ul>
+        \\<li>bar</li>
+        \\<li>baz</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 304" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\The
+    );
+    const html = (
+        \\<p>The
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 305" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\The
+    );
+    const html = (
+        \\<p>The
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 306" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\</li>
+        \\<li>
+        \\<p>bar</p>
+        \\</li>
+        \\<li>
+        \\<p>baz</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 307" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo
+        \\<ul>
+        \\<li>bar
+        \\<ul>
+        \\<li>
+        \\<p>baz</p>
+        \\<p>bim</p>
+        \\</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 308" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>foo</li>
+        \\<li>bar</li>
+        \\</ul>
+        \\<!--
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 309" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<p>notcode</p>
+        \\</li>
+        \\<li>
+        \\<p>foo</p>
+        \\</li>
+        \\</ul>
+        \\<!--
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 310" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a</li>
+        \\<li>b</li>
+        \\<li>c</li>
+        \\<li>d</li>
+        \\<li>e</li>
+        \\<li>f</li>
+        \\<li>g</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 311" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>a</p>
+        \\</li>
+        \\<li>
+        \\<p>b</p>
+        \\</li>
+        \\<li>
+        \\<p>c</p>
+        \\</li>
+        \\</ol>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 312" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a</li>
+        \\<li>b</li>
+        \\<li>c</li>
+        \\<li>d
+        \\-
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 313" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<p>a</p>
+        \\</li>
+        \\<li>
+        \\<p>b</p>
+        \\</li>
+        \\</ol>
+        \\<pre><code>3.
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 314" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>a</p>
+        \\</li>
+        \\<li>
+        \\<p>b</p>
+        \\</li>
+        \\<li>
+        \\<p>c</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 315" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>a</p>
+        \\</li>
+        \\<li></li>
+        \\<li>
+        \\<p>c</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 316" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>a</p>
+        \\</li>
+        \\<li>
+        \\<p>b</p>
+        \\<p>c</p>
+        \\</li>
+        \\<li>
+        \\<p>d</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 317" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>a</p>
+        \\</li>
+        \\<li>
+        \\<p>b</p>
+        \\</li>
+        \\<li>
+        \\<p>d</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 318" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a</li>
+        \\<li>
+        \\<pre><code>b
+        \\
+        \\
+        \\</code></pre>
+        \\</li>
+        \\<li>c</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 319" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a
+        \\<ul>
+        \\<li>
+        \\<p>b</p>
+        \\<p>c</p>
+        \\</li>
+        \\</ul>
+        \\</li>
+        \\<li>d</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 320" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*
+    );
+    const html = (
+        \\<ul>
+        \\<li>a
+        \\<blockquote>
+        \\<p>b</p>
+        \\</blockquote>
+        \\</li>
+        \\<li>c</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 321" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a
+        \\<blockquote>
+        \\<p>b</p>
+        \\</blockquote>
+        \\<pre><code>c
+        \\</code></pre>
+        \\</li>
+        \\<li>d</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 322" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 323" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>a
+        \\<ul>
+        \\<li>b</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 324" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\1.
+    );
+    const html = (
+        \\<ol>
+        \\<li>
+        \\<pre><code>foo
+        \\</code></pre>
+        \\<p>bar</p>
+        \\</li>
+        \\</ol>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 325" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>foo</p>
+        \\<ul>
+        \\<li>bar</li>
+        \\</ul>
+        \\<p>baz</p>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 326" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\-
+    );
+    const html = (
+        \\<ul>
+        \\<li>
+        \\<p>a</p>
+        \\<ul>
+        \\<li>b</li>
+        \\<li>c</li>
+        \\</ul>
+        \\</li>
+        \\<li>
+        \\<p>d</p>
+        \\<ul>
+        \\<li>e</li>
+        \\<li>f</li>
+        \\</ul>
+        \\</li>
+        \\</ul>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 327" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`hi`lo`
+    );
+    const html = (
+        \\<p><code>hi</code>lo`</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 328" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`foo`
+    );
+    const html = (
+        \\<p><code>foo</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 329" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\``
+    );
+    const html = (
+        \\<p><code>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 330" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`
+    );
+    const html = (
+        \\<p><code>``</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 331" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`
+    );
+    const html = (
+        \\<p><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 332" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`
+    );
+    const html = (
+        \\<p><code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 333" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\` b `
+    );
+    const html = (
+        \\<p><code> b </code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 334" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\` `
+        \\`
+    );
+    const html = (
+        \\<p><code> </code>
+        \\<code>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 335" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\``
+        \\foo
+        \\bar
+    );
+    const html = (
+        \\<p><code>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 336" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\``
+        \\foo
+    );
+    const html = (
+        \\<p><code>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 337" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`foo
+    );
+    const html = (
+        \\<p><code>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 338" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`foo\`bar`
+    );
+    const html = (
+        \\<p><code>foo\</code>bar`</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 339" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\``foo`bar``
+    );
+    const html = (
+        \\<p><code>foo`bar</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 340" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`
+    );
+    const html = (
+        \\<p><code>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 341" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo`*`
+    );
+    const html = (
+        \\<p>*foo<code>*</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 342" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[not
+    );
+    const html = (
+        \\<p>[not
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 343" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`<a
+    );
+    const html = (
+        \\<p><code>&lt;a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 344" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 345" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`<https://foo.bar.`baz>`
+    );
+    const html = (
+        \\<p><code>&lt;https://foo.bar.</code>baz&gt;`</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 346" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<https://foo.bar.`baz>`
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 347" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\```foo``
+    );
+    const html = (
+        \\<p>```foo``</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 348" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`foo
+    );
+    const html = (
+        \\<p>`foo</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 349" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`foo``bar``
+    );
+    const html = (
+        \\<p>`foo<code>bar</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 350" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 351" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a
+    );
+    const html = (
+        \\<p>a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 352" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a*"foo"*
+    );
+    const html = (
+        \\<p>a*&quot;foo&quot;*</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 353" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\* a *
+    );
+    const html = (
+        \\<p>* a *</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 354" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*$*alpha.
+        \\
+        \\*£*bravo.
+        \\
+        \\*€*charlie.
+    );
+    const html = (
+        \\<p>*$*alpha.</p>
+        \\<p>*£*bravo.</p>
+        \\<p>*€*charlie.</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 355" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo*bar*
+    );
+    const html = (
+        \\<p>foo<em>bar</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 356" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\5*6*78
+    );
+    const html = (
+        \\<p>5<em>6</em>78</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 357" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 358" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_
+    );
+    const html = (
+        \\<p>_
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 359" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a_"foo"_
+    );
+    const html = (
+        \\<p>a_&quot;foo&quot;_</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 360" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo_bar_
+    );
+    const html = (
+        \\<p>foo_bar_</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 361" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\5_6_78
+    );
+    const html = (
+        \\<p>5_6_78</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 362" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\пристаням_стремятся_
+    );
+    const html = (
+        \\<p>пристаням_стремятся_</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 363" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\aa_"bb"_cc
+    );
+    const html = (
+        \\<p>aa_&quot;bb&quot;_cc</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 364" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo-_(bar)_
+    );
+    const html = (
+        \\<p>foo-<em>(bar)</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 365" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo*
+    );
+    const html = (
+        \\<p>_foo*</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 366" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p>*foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 367" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p>*foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 368" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*(*foo)
+    );
+    const html = (
+        \\<p>*(*foo)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 369" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*(*foo*)*
+    );
+    const html = (
+        \\<p><em>(<em>foo</em>)</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 370" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo*bar
+    );
+    const html = (
+        \\<p><em>foo</em>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 371" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo
+    );
+    const html = (
+        \\<p>_foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 372" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_(_foo)
+    );
+    const html = (
+        \\<p>_(_foo)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 373" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_(_foo_)_
+    );
+    const html = (
+        \\<p><em>(<em>foo</em>)</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 374" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo_bar
+    );
+    const html = (
+        \\<p>_foo_bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 375" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_пристаням_стремятся
+    );
+    const html = (
+        \\<p>_пристаням_стремятся</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 376" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo_bar_baz_
+    );
+    const html = (
+        \\<p><em>foo_bar_baz</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 377" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_(bar)_.
+    );
+    const html = (
+        \\<p><em>(bar)</em>.</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 378" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 379" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**
+    );
+    const html = (
+        \\<p>**
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 380" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a**"foo"**
+    );
+    const html = (
+        \\<p>a**&quot;foo&quot;**</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 381" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo**bar**
+    );
+    const html = (
+        \\<p>foo<strong>bar</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 382" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 383" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__
+    );
+    const html = (
+        \\<p>__
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 384" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__
+        \\foo
+    );
+    const html = (
+        \\<p>__
+        \\foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 385" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\a__"foo"__
+    );
+    const html = (
+        \\<p>a__&quot;foo&quot;__</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 386" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo__bar__
+    );
+    const html = (
+        \\<p>foo__bar__</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 387" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\5__6__78
+    );
+    const html = (
+        \\<p>5__6__78</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 388" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\пристаням__стремятся__
+    );
+    const html = (
+        \\<p>пристаням__стремятся__</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 389" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo,
+    );
+    const html = (
+        \\<p><strong>foo,
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 390" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo-__(bar)__
+    );
+    const html = (
+        \\<p>foo-<strong>(bar)</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 391" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p>**foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 392" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**(**foo)
+    );
+    const html = (
+        \\<p>**(**foo)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 393" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*(**foo**)*
+    );
+    const html = (
+        \\<p><em>(<strong>foo</strong>)</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 394" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**Gomphocarpus
+    );
+    const html = (
+        \\<p><strong>Gomphocarpus
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 395" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 396" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo**bar
+    );
+    const html = (
+        \\<p><strong>foo</strong>bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 397" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo
+    );
+    const html = (
+        \\<p>__foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 398" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__(__foo)
+    );
+    const html = (
+        \\<p>__(__foo)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 399" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_(__foo__)_
+    );
+    const html = (
+        \\<p><em>(<strong>foo</strong>)</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 400" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo__bar
+    );
+    const html = (
+        \\<p>__foo__bar</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 401" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__пристаням__стремятся
+    );
+    const html = (
+        \\<p>__пристаням__стремятся</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 402" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo__bar__baz__
+    );
+    const html = (
+        \\<p><strong>foo__bar__baz</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 403" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__(bar)__.
+    );
+    const html = (
+        \\<p><strong>(bar)</strong>.</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 404" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 405" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+        \\bar*
+    );
+    const html = (
+        \\<p><em>foo
+        \\bar</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 406" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 407" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 408" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo_
+    );
+    const html = (
+        \\<p><em><em>foo</em>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 409" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 410" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 411" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo**bar**baz*
+    );
+    const html = (
+        \\<p><em>foo<strong>bar</strong>baz</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 412" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo**bar*
+    );
+    const html = (
+        \\<p><em>foo**bar</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 413" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***foo**
+    );
+    const html = (
+        \\<p><em><strong>foo</strong>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 414" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 415" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo**bar***
+    );
+    const html = (
+        \\<p><em>foo<strong>bar</strong></em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 416" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo***bar***baz
+    );
+    const html = (
+        \\<p>foo<em><strong>bar</strong></em>baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 417" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo******bar*********baz
+    );
+    const html = (
+        \\<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 418" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 419" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 420" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**
+    );
+    const html = (
+        \\<p>**
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 421" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\****
+    );
+    const html = (
+        \\<p>****
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 422" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 423" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+        \\bar**
+    );
+    const html = (
+        \\<p><strong>foo
+        \\bar</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 424" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 425" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 426" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\____foo__
+    );
+    const html = (
+        \\<p><strong><strong>foo</strong>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 427" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 428" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 429" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo*bar*baz**
+    );
+    const html = (
+        \\<p><strong>foo<em>bar</em>baz</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 430" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***foo*
+    );
+    const html = (
+        \\<p><strong><em>foo</em>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 431" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 432" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 433" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p><strong>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 434" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__
+    );
+    const html = (
+        \\<p>__
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 435" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\____
+    );
+    const html = (
+        \\<p>____
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 436" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 437" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 438" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 439" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 440" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 441" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 442" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo*
+    );
+    const html = (
+        \\<p>*<em>foo</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 443" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo**
+    );
+    const html = (
+        \\<p><em>foo</em>*</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 444" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***foo**
+    );
+    const html = (
+        \\<p>*<strong>foo</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 445" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\****foo*
+    );
+    const html = (
+        \\<p>***<em>foo</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 446" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo***
+    );
+    const html = (
+        \\<p><strong>foo</strong>*</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 447" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo****
+    );
+    const html = (
+        \\<p><em>foo</em>***</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 448" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 449" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 450" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 451" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 452" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 453" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 454" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo_
+    );
+    const html = (
+        \\<p>_<em>foo</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 455" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo__
+    );
+    const html = (
+        \\<p><em>foo</em>_</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 456" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\___foo__
+    );
+    const html = (
+        \\<p>_<strong>foo</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 457" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\____foo_
+    );
+    const html = (
+        \\<p>___<em>foo</em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 458" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo___
+    );
+    const html = (
+        \\<p><strong>foo</strong>_</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 459" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo____
+    );
+    const html = (
+        \\<p><em>foo</em>___</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 460" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo**
+    );
+    const html = (
+        \\<p><strong>foo</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 461" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*_foo_*
+    );
+    const html = (
+        \\<p><em><em>foo</em></em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 462" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__foo__
+    );
+    const html = (
+        \\<p><strong>foo</strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 463" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_*foo*_
+    );
+    const html = (
+        \\<p><em><em>foo</em></em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 464" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\****foo****
+    );
+    const html = (
+        \\<p><strong><strong>foo</strong></strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 465" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\____foo____
+    );
+    const html = (
+        \\<p><strong><strong>foo</strong></strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 466" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\******foo******
+    );
+    const html = (
+        \\<p><strong><strong><strong>foo</strong></strong></strong></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 467" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\***foo***
+    );
+    const html = (
+        \\<p><em><strong>foo</strong></em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 468" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_____foo_____
+    );
+    const html = (
+        \\<p><em><strong><strong>foo</strong></strong></em></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 469" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 470" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 471" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**foo
+    );
+    const html = (
+        \\<p>**foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 472" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p>*foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 473" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*[bar*](/url)
+    );
+    const html = (
+        \\<p>*<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 474" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_foo
+    );
+    const html = (
+        \\<p>_foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 475" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*<img
+    );
+    const html = (
+        \\<p>*<img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 476" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**<a
+    );
+    const html = (
+        \\<p>**<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 477" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__<a
+    );
+    const html = (
+        \\<p>__<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 478" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*a
+    );
+    const html = (
+        \\<p><em>a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 479" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\_a
+    );
+    const html = (
+        \\<p><em>a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 480" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\**a<https://foo.bar/?q=**>
+    );
+    const html = (
+        \\<p>**a<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 481" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\__a<https://foo.bar/?q=__>
+    );
+    const html = (
+        \\<p>__a<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 482" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/uri
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 483" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/uri)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 484" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[](./target.md)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 485" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link]()
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 486" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](<>)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 487" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[]()
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 488" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/my
+    );
+    const html = (
+        \\<p>[link](/my
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 489" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](</my
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 490" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo
+        \\bar)
+    );
+    const html = (
+        \\<p>[link](foo
+        \\bar)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 491" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](<foo
+        \\bar>)
+    );
+    const html = (
+        \\<p>[link](<foo
+        \\bar>)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 492" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[a](<b)c>)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 493" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](<foo\>)
+    );
+    const html = (
+        \\<p>[link](&lt;foo&gt;)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 494" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[a](<b)c
+        \\[a](<b)c>
+        \\[a](<b>c)
+    );
+    const html = (
+        \\<p>[a](&lt;b)c
+        \\[a](&lt;b)c&gt;
+        \\[a](<b>c)</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 495" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](\(foo\))
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 496" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo(and(bar)))
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 497" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo(and(bar))
+    );
+    const html = (
+        \\<p>[link](foo(and(bar))</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 498" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo\(and\(bar\))
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 499" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](<foo(and(bar)>)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 500" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo\)\:)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 501" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](#fragment)
+        \\
+        \\[link](https://example.com#fragment)
+        \\
+        \\[link](https://example.com?foo=3#frag)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 502" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo\bar)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 503" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](foo%20b&auml;)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 504" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link]("title")
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 505" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/url
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 506" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/url
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 507" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/url "title")
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 508" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/url
+    );
+    const html = (
+        \\<p>[link](/url
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 509" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](/url
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 510" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link](
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 511" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link]
+    );
+    const html = (
+        \\<p>[link]
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 512" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 513" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link]
+    );
+    const html = (
+        \\<p>[link]
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 514" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p>[link
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 515" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 516" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 517" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[![moon](moon.jpg)](/uri)
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 518" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p>[foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 519" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p>[foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 520" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![[[foo](uri1)](uri2)](uri3)
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 521" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*[foo*](/uri)
+    );
+    const html = (
+        \\<p>*<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 522" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 523" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 524" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p>[foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 525" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo`](/uri)`
+    );
+    const html = (
+        \\<p>[foo<code>](/uri)</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 526" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo<https://example.com/?search=](uri)>
+    );
+    const html = (
+        \\<p>[foo<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 527" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][bar]
+        \\
+        \\[bar]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 528" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 529" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 530" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[link
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 531" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[![moon](moon.jpg)][ref]
+        \\
+        \\[ref]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 532" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p>[foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 533" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p>[foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 534" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*[foo*][ref]
+        \\
+        \\[ref]:
+    );
+    const html = (
+        \\<p>*<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 535" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 536" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo
+    );
+    const html = (
+        \\<p>[foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 537" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo`][ref]`
+        \\
+        \\[ref]:
+    );
+    const html = (
+        \\<p>[foo<code>][ref]</code></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 538" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo<https://example.com/?search=][ref]>
+        \\
+        \\[ref]:
+    );
+    const html = (
+        \\<p>[foo<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 539" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][BaR]
+        \\
+        \\[bar]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 540" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[ẞ]
+        \\
+        \\[SS]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 541" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[Foo
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 542" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+    );
+    const html = (
+        \\<p>[foo]
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 543" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\[bar]
+        \\
+        \\[bar]:
+    );
+    const html = (
+        \\<p>[foo]
+        \\<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 544" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 545" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[bar][foo\!]
+        \\
+        \\[foo!]:
+    );
+    const html = (
+        \\<p>[bar][foo!]</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 546" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][ref[]
+        \\
+        \\[ref[]:
+    );
+    const html = (
+        \\<p>[foo][ref[]</p>
+        \\<p>[ref[]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 547" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][ref[bar]]
+        \\
+        \\[ref[bar]]:
+    );
+    const html = (
+        \\<p>[foo][ref[bar]]</p>
+        \\<p>[ref[bar]]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 548" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[[[foo]]]
+        \\
+        \\[[[foo]]]:
+    );
+    const html = (
+        \\<p>[[[foo]]]</p>
+        \\<p>[[[foo]]]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 549" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][ref\[]
+        \\
+        \\[ref\[]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 550" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[bar\\]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 551" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[]
+        \\
+        \\[]:
+    );
+    const html = (
+        \\<p>[]</p>
+        \\<p>[]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 552" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[
+    );
+    const html = (
+        \\<p>[
+        \\]</p>
+        \\<p>[
+        \\]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 553" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 554" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[*foo*
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 555" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[Foo][]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 556" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 557" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 558" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[*foo*
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 559" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[[*foo*
+    );
+    const html = (
+        \\<p>[<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 560" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[[bar
+    );
+    const html = (
+        \\<p>[[bar
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 561" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[Foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 562" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 563" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p>[foo]</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 564" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo*]:
+    );
+    const html = (
+        \\<p>*<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 565" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][bar]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 566" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 567" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo]()
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 568" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo](not
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 569" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][bar][baz]
+        \\
+        \\[baz]:
+    );
+    const html = (
+        \\<p>[foo]<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 570" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][bar][baz]
+        \\
+        \\[baz]:
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 571" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\[foo][bar][baz]
+        \\
+        \\[baz]:
+    );
+    const html = (
+        \\<p>[foo]<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 572" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo](/url
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 573" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 574" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 575" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 576" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 577" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 578" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo](train.jpg)
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 579" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\My
+    );
+    const html = (
+        \\<p>My
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 580" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo](<url>)
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 581" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![](/url)
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 582" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo][bar]
+        \\
+        \\[bar]:
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 583" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo][bar]
+        \\
+        \\[BAR]:
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 584" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo][]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 585" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![*foo*
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 586" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![Foo][]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 587" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo]
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 588" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 589" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![*foo*
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 590" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![[foo]]
+        \\
+        \\[[foo]]:
+    );
+    const html = (
+        \\<p>![[foo]]</p>
+        \\<p>[[foo]]:
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 591" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\![Foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p><img
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 592" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\!\[foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p>![foo]</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 593" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\\![foo]
+        \\
+        \\[foo]:
+    );
+    const html = (
+        \\<p>!<a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 594" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<http://foo.bar.baz>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 595" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<https://foo.bar.baz/test?q=hello&id=22&boolean>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 596" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<irc://foo.bar:2233/baz>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 597" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<MAILTO:FOO@BAR.BAZ>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 598" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a+b+c:d>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 599" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<made-up-scheme://foo,bar>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 600" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<https://../>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 601" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<localhost:5001/foo>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 602" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<https://foo.bar/baz
+    );
+    const html = (
+        \\<p>&lt;https://foo.bar/baz
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 603" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<https://example.com/\[\>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 604" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<foo@bar.example.com>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 605" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<foo+special@Bar.baz-bar0.com>
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 606" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<foo\+@bar.example.com>
+    );
+    const html = (
+        \\<p>&lt;foo+@bar.example.com&gt;</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 607" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<>
+    );
+    const html = (
+        \\<p>&lt;&gt;</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 608" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<
+    );
+    const html = (
+        \\<p>&lt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 609" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<m:abc>
+    );
+    const html = (
+        \\<p>&lt;m:abc&gt;</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 610" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<foo.bar.baz>
+    );
+    const html = (
+        \\<p>&lt;foo.bar.baz&gt;</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 611" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\https://example.com
+    );
+    const html = (
+        \\<p>https://example.com</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 612" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo@bar.example.com
+    );
+    const html = (
+        \\<p>foo@bar.example.com</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 613" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a><bab><c2c>
+    );
+    const html = (
+        \\<p><a><bab><c2c></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 614" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a/><b2/>
+    );
+    const html = (
+        \\<p><a/><b2/></p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 615" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 616" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 617" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<p>Foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 618" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<33>
+    );
+    const html = (
+        \\<p>&lt;33&gt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 619" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p>&lt;a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 620" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p>&lt;a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 621" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<
+    );
+    const html = (
+        \\<p>&lt;
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 622" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p>&lt;a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 623" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\</a></foo
+    );
+    const html = (
+        \\<p></a></foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 624" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\</a
+    );
+    const html = (
+        \\<p>&lt;/a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 625" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 626" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 627" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 628" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 629" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 630" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 631" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 632" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p>&lt;a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 633" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 634" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo\
+        \\baz
+    );
+    const html = (
+        \\<p>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 635" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 636" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 637" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo\
+    );
+    const html = (
+        \\<p>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 638" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo
+    );
+    const html = (
+        \\<p><em>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 639" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\*foo\
+        \\bar*
+    );
+    const html = (
+        \\<p><em>foo<br
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 640" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`code
+    );
+    const html = (
+        \\<p><code>code
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 641" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\`code\
+        \\span`
+    );
+    const html = (
+        \\<p><code>code\
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 642" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 643" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\<a
+    );
+    const html = (
+        \\<p><a
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 644" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo\
+    );
+    const html = (
+        \\<p>foo\</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 645" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 646" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\###
+    );
+    const html = (
+        \\<h3>foo\</h3>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 647" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\###
+    );
+    const html = (
+        \\<h3>foo</h3>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 648" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+        \\baz
+    );
+    const html = (
+        \\<p>foo
+        \\baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 649" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\foo
+    );
+    const html = (
+        \\<p>foo
+        \\baz</p>
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 650" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\hello
+    );
+    const html = (
+        \\<p>hello
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 651" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Foo
+    );
+    const html = (
+        \\<p>Foo
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
+
+test "Example 652" {
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\Multiple
+    );
+    const html = (
+        \\<p>Multiple
+    );
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
+}
diff --git a/src/main.zig b/src/main.zig
new file mode 100644
index 0000000..249e7bf
--- /dev/null
+++ b/src/main.zig
@@ -0,0 +1,61 @@
+const std = @import("std");
+
+pub fn find_blocks(src: []const u8, blocks: *std.ArrayList([]const u8)) !void {
+    var idx: usize = 0;
+    var blk: usize = 0;
+
+    while (idx < src.len) {
+        const end = std.mem.indexOfAnyPos(u8, src, idx, "\n") orelse src.len;
+        const line = src[idx..end];
+        if (std.mem.indexOfNone(u8, line, " \t\r\n") == null) {
+            // the line is blank; a block has ended.
+            const block = src[blk..end];
+
+            std.debug.print("BLOCK:\n{s}", .{block});
+
+            try blocks.append(block);
+            blk = end + 1;
+        }
+        idx = end + 1;
+    }
+}
+
+pub fn convert(alloc: std.mem.Allocator, md: []const u8) ![]const u8 {
+    _ = alloc;
+    _ = md;
+    return error.UhOh;
+    // return error.NotImplemented;
+}
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const alloc = gpa.allocator();
+
+    defer _ = gpa.deinit();
+
+    var args = try std.process.argsWithAllocator(alloc);
+    defer args.deinit();
+    std.debug.assert(args.skip());
+
+    var blocks = std.ArrayList([]const u8).init(alloc);
+    defer blocks.deinit();
+
+    while (args.next()) |fname| {
+        const src = load: {
+            const file = try std.fs.cwd().openFile(fname, .{ .mode = .read_only });
+            defer file.close();
+            break :load try file.readToEndAlloc(alloc, std.math.maxInt(u32));
+        };
+        defer alloc.free(src);
+
+        std.log.debug("arg '{s}' {d} bytes", .{ fname, src.len });
+
+        blocks.clearRetainingCapacity();
+        try find_blocks(src, &blocks);
+
+        // try parse(alloc, src);
+
+        // const tokens = try parse(alloc, src);
+        // defer alloc.free(tokens);
+    }
+}