diff --git a/docs/docs/rich-text-formatting/markdown-streaming.md b/docs/docs/rich-text-formatting/markdown-streaming.md
index 5939d576b..15a0e30b9 100644
--- a/docs/docs/rich-text-formatting/markdown-streaming.md
+++ b/docs/docs/rich-text-formatting/markdown-streaming.md
@@ -52,7 +52,7 @@ It takes **two** conditions, not one: `streamingAnimation` must be on **and** th
 
 | Mode | Behavior |
 | --- | --- |
-| `'progressive'` (default) | Streams the code line-by-line with a visible but non-interactive header (copying is disabled until the block completes); syntax highlighting is deferred until the closing fence so it does not flicker on every token. The block appears once the line that opens the fence has ended, so its language label never changes. |
+| `'progressive'` (default) | Streams the code line-by-line with a visible but non-interactive header (copying is disabled until the block completes); syntax highlighting is deferred until the closing fence so it does not flicker on every token. The block appears once the line that opens the fence has ended, so its language label never changes. The first one or two backticks or tildes of a fence, and the start of its closing fence (including the quote markers or indent before it), are withheld until the next character arrives, so they never flash as text or as a line of code. A fence that starts a list item or quote keeps its bullet or quote bar while it waits. |
 | `'hidden'` | Withholds the whole block until its closing fence arrives, then shows it complete. |
 
 A code block drawn by [`renderers.code`](/react-native/guides/custom-block-renderers#code-blocks) follows the same modes. In `'progressive'` its element re-renders with the growing code and receives `isComplete: false` until the closing fence arrives.
@@ -64,7 +64,7 @@ A code block drawn by [`renderers.code`](/react-native/guides/custom-block-rende
 | `'progressive'` (default) | Shows a trailing image paragraph, link paragraph or `<video>` block once its syntax is complete. A half-streamed `![alt](https://…` or `[label](https://…` is withheld instead of flashing as text, and a partial `<video` tag is not shown. A bare URL on its own line can always grow, so it is withheld until the next line arrives. |
 | `'hidden'` | Withholds the block until a blank line or another block follows it, like `tableMode: 'hidden'`. Applies to native images and to blocks drawn by [`renderers`](/react-native/guides/custom-block-renderers). |
 
-**Block math** has no mode key. An unterminated `$$` block is always withheld, truncated at the opening delimiter, until the closing `$$` arrives. On a page of LLM output that routinely contains LaTeX, this is the third incomplete-block case to expect.
+**Block math** has no mode key. An unterminated `$$` block is always withheld, truncated at the opening delimiter, until the closing `$$` arrives. A lone `$` at the start of a line is held back the same way until the next character shows whether it opens a `$$` block. On a page of LLM output that routinely contains LaTeX, this is the third incomplete-block case to expect.
 
 <LivePreview src={StreamingSrc} unavailable unavailableReason={<>iOS and Android only - <code>streamingAnimation</code> and <code>streamingConfig</code> are stripped on web.</>} />
 
diff --git a/packages/core/cpp/parser/StreamingFilter.cpp b/packages/core/cpp/parser/StreamingFilter.cpp
index ed48762c5..6add79092 100644
--- a/packages/core/cpp/parser/StreamingFilter.cpp
+++ b/packages/core/cpp/parser/StreamingFilter.cpp
@@ -70,6 +70,11 @@ size_t leadingSpaces(std::string_view text) {
 
 // ---- containers
 
+// Where `part`, a view into `line`, starts in it.
+size_t offsetIn(std::string_view line, std::string_view part) {
+  return static_cast<size_t>(part.data() - line.data());
+}
+
 // A line without its blockquote markers.
 struct Quoted {
   std::string_view body;
@@ -195,6 +200,20 @@ bool parseFenceMarker(std::string_view line, FenceMarker &out) {
   return true;
 }
 
+// Whether `line` is so far only the first `maxRun` or fewer characters of a
+// fence marker: up to three spaces, then a run of one fence character (`ch`, or
+// either kind when it is 0) and nothing after it. On the last line of a stream
+// the next character decides whether it is a fence or text.
+bool isFenceMarkerPrefix(std::string_view line, char ch, size_t maxRun) {
+  size_t i = leadingSpaces(line);
+  if (i > 3 || i >= line.size())
+    return false;
+  char mark = line[i];
+  if ((mark != '`' && mark != '~') || (ch != 0 && mark != ch))
+    return false;
+  return line.size() - i <= maxRun && line.find_first_not_of(mark, i) == npos;
+}
+
 // Reference labels match case-insensitively with whitespace runs collapsed.
 std::string normalizeLabel(std::string_view label) {
   std::string normalized;
@@ -224,6 +243,17 @@ void recordDefinition(std::string_view content, std::unordered_set<std::string>
 
 struct BlockScan {
   size_t openFence = npos; // the opening line of a fence still open at the end
+  // Where that line's fence marker starts, after any quote markers, list marker
+  // and indent: the part before it stays shown while the fence is withheld.
+  size_t openFenceMarker = npos;
+  // Where the last line's characters start when they are only the beginning of
+  // a block delimiter: one or two characters of a fence opener, the start of
+  // the closing fence of an open block, or the first `$` of a `$$` line. Inside
+  // an open fence, a last line that holds only whitespace or container markers
+  // is withheld from its start, since md4c would read it as a blank code line.
+  // The filter withholds them until the next character decides, so they never
+  // show as text or as a line of code that then disappears (#1130).
+  size_t pendingDelimiter = npos;
   std::unordered_set<std::string> definitions;
 };
 
@@ -246,16 +276,22 @@ BlockScan scanBlocks(Lines &lines) {
     bool blank = isBlank(body);
     size_t lead = leadingSpaces(body);
     if (inFence) {
-      // A blank last line has not streamed its quote markers in yet, so it cannot
-      // end a quoted fence.
-      bool undecided = i + 1 == lines.size() && isBlank(lines[i].text);
+      // A last line of only whitespace and quote markers has not streamed all of
+      // its markers in yet, so it cannot end a quoted fence. Until more arrives
+      // it is not shown either: md4c would read it as a blank line of code.
+      bool undecided = i + 1 == lines.size() && blank && quoted.depth <= fence.depth;
       bool containerEnded = !undecided && (quoted.depth < fence.depth || (!blank && lead < fence.indent));
+      if (undecided && !lines[i].text.empty())
+        scan.pendingDelimiter = lines[i].offset;
       if (!containerEnded) {
         lines[i].code = true;
         FenceMarker marker;
-        if (!blank && parseFenceMarker(body.substr(fence.indent), marker) && marker.ch == fence.ch &&
-            marker.length >= fence.length && isBlank(marker.info))
+        std::string_view inner = blank ? std::string_view() : body.substr(fence.indent);
+        if (!blank && parseFenceMarker(inner, marker) && marker.ch == fence.ch && marker.length >= fence.length &&
+            isBlank(marker.info))
           inFence = false;
+        else if (!blank && i + 1 == lines.size() && isFenceMarkerPrefix(inner, fence.ch, fence.length - 1))
+          scan.pendingDelimiter = lines[i].offset + offsetIn(lines[i].text, inner) + leadingSpaces(inner);
         continue;
       }
       inFence = false;
@@ -279,8 +315,15 @@ BlockScan scanBlocks(Lines &lines) {
       fence = {marker.ch, marker.length, quoted.depth, indent};
       lines[i].code = true;
       scan.openFence = i;
+      scan.openFenceMarker = lines[i].offset + offsetIn(lines[i].text, content) + leadingSpaces(content);
       continue;
     }
+    if (i + 1 == lines.size()) {
+      if (isFenceMarkerPrefix(content, 0, 2))
+        scan.pendingDelimiter = lines[i].offset + offsetIn(lines[i].text, content) + leadingSpaces(content);
+      else if (trim(body) == "$") // the block math rule reads `$$` lines the same way
+        scan.pendingDelimiter = lines[i].offset + offsetIn(lines[i].text, body) + leadingSpaces(body);
+    }
     recordDefinition(content, scan.definitions);
   }
   if (!inFence)
@@ -588,6 +631,10 @@ StreamingFilterResult renderableMarkdownForStreaming(const std::string &markdown
   std::string_view text(markdown);
   Lines lines = splitLines(text);
   BlockScan scan = scanBlocks(lines);
+  // The characters of a delimiter still being typed are withheld: the result is
+  // the one the stream had before they arrived.
+  if (scan.pendingDelimiter != npos)
+    return renderableMarkdownForStreaming(markdown.substr(0, scan.pendingDelimiter), options);
   if (scan.openFence == npos)
     return {std::string(removePendingBlocks({text, std::move(lines)}, options, false, scan)), false};
 
@@ -599,8 +646,14 @@ StreamingFilterResult renderableMarkdownForStreaming(const std::string &markdown
   size_t fenceOffset = head.lines[scan.openFence].offset;
   head.cutAtLine(scan.openFence);
   std::string_view kept = removePendingBlocks(std::move(head), options, true, scan);
-  if (options.codeBlockMode == StreamingBlockMode::Hidden || !openerEnded)
-    return {std::string(kept), false};
+  if (options.codeBlockMode == StreamingBlockMode::Hidden || !openerEnded) {
+    // Only the fence is withheld: the quote markers, list marker or indent before
+    // it on its line stay, so a list item or quote that starts with a fence keeps
+    // its bullet or bar while the fence waits.
+    std::string result(kept);
+    result.append(text.substr(fenceOffset, scan.openFenceMarker - fenceOffset));
+    return {std::move(result), false};
+  }
   std::string result;
   result.reserve(kept.size() + text.size() - fenceOffset);
   result.append(kept).append(text.substr(fenceOffset));
diff --git a/packages/core/cpp/parser/StreamingFilter.hpp b/packages/core/cpp/parser/StreamingFilter.hpp
index 9dd888a4d..b06d66078 100644
--- a/packages/core/cpp/parser/StreamingFilter.hpp
+++ b/packages/core/cpp/parser/StreamingFilter.hpp
@@ -28,13 +28,18 @@ struct StreamingFilterResult {
 //   * tables: Hidden withholds a trailing table until a blank line follows it,
 //     Progressive trims an incomplete trailing row;
 //   * fenced code: Hidden cuts an open fence, Progressive keeps it once its
-//     opening line has ended and filters only the text before it;
+//     opening line has ended and filters only the text before it. Either way a
+//     cut fence keeps the quote markers or list marker before it on its line;
 //   * media (a trailing image paragraph, link-only paragraph or `<video>`
 //     block, the blocks a renderer can replace): Hidden withholds it
 //     until a blank line or another block follows, Progressive withholds it only
 //     while its syntax is still open;
 //   * an inline image or link still being typed at the end of the last
 //     paragraph (`text ![alt](https://`) is cut so it never shows as text.
+//   * the first characters of a delimiter still being typed on the last line
+//     (one or two of a fence opener, the start of an open fence's closing
+//     fence or only its quote markers or indent, a lone `$` before `$$`) are
+//     withheld until the next one decides.
 StreamingFilterResult renderableMarkdownForStreaming(const std::string &markdown,
                                                      const StreamingFilterOptions &options);
 
diff --git a/packages/core/cpp/tests/streaming_filter_fuzz.cpp b/packages/core/cpp/tests/streaming_filter_fuzz.cpp
index 936b43d8a..89090a72f 100644
--- a/packages/core/cpp/tests/streaming_filter_fuzz.cpp
+++ b/packages/core/cpp/tests/streaming_filter_fuzz.cpp
@@ -2,16 +2,20 @@
  * Streams every fixture one byte at a time through the filter and parses each
  * prefix with md4c: image, link and video syntax that the whole document
  * parses as syntax must never reach the screen as literal text while it
- * streams. md4c is the oracle, so the filter cannot drift from the parser.
+ * streams, and neither must the first characters of a code fence or a `$$`
+ * line (as prose, or as a line of code before the closing fence completes).
+ * md4c is the oracle, so the filter cannot drift from the parser.
  * See scripts/test-core-parser.sh.
  */
 #include "MD4CParser.hpp"
 #include "StreamingFilter.hpp"
+#include <algorithm>
 #include <cstring>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <string>
+#include <vector>
 
 namespace {
 
@@ -55,6 +59,19 @@ two lines](https://e.com/wrapped) and goes on.
 > const link = "[a](b)";
 > ```
 
+- Install it:
+  ```sh
+  npm i "[pkg](x)"
+  ```
+
+~~~~py
+print("```")
+~~~~
+
+$$
+e^{i\pi} + 1 = 0
+$$
+
 Prices were [about 500 yen][prices], see [notes] and [![thumb](https://e.com/t.jpg)](https://e.com/full.jpg).
 
 [inari]: https://e.com/inari
@@ -91,11 +108,47 @@ bool leaksSyntax(const std::string &fragment, const std::string &wholeText) {
   return false;
 }
 
+// The text of each code block, in document order.
+void collectCode(const MarkdownASTNode &node, std::vector<std::string> &out) {
+  if (node.type == NodeType::CodeBlock) {
+    std::string code;
+    collectText(node, code);
+    out.push_back(code);
+    return;
+  }
+  for (const auto &child : node.children)
+    collectCode(*child, out);
+}
+
+// A text fragment made only of fence characters, or a lone `$`: the start of a
+// fence or `$$` line shown before the rest of it arrived, unless the finished
+// document holds the same text.
+bool flashesDelimiter(const std::string &fragment, const std::string &wholeText) {
+  size_t start = fragment.find_first_not_of(' ');
+  if (start == std::string::npos)
+    return false;
+  size_t end = fragment.find_last_not_of(' ');
+  std::string marks = fragment.substr(start, end - start + 1);
+  bool fenceChars =
+      marks.find_first_not_of('`') == std::string::npos || marks.find_first_not_of('~') == std::string::npos;
+  if (!fenceChars && marks != "$")
+    return false;
+  std::istringstream lines(wholeText);
+  for (std::string line; std::getline(lines, line);) {
+    if (line == fragment)
+      return false;
+  }
+  return true;
+}
+
 int checkDocument(const std::string &name, const std::string &document) {
   Markdown::MD4CParser parser;
   std::string wholeText;
-  if (auto root = parser.parse(document))
+  std::vector<std::string> wholeCode;
+  if (auto root = parser.parse(document)) {
     collectText(*root, wholeText);
+    collectCode(*root, wholeCode);
+  }
   int failures = 0;
   for (StreamingBlockMode mode : {StreamingBlockMode::Progressive, StreamingBlockMode::Hidden}) {
     Markdown::StreamingFilterOptions options;
@@ -111,6 +164,20 @@ int checkDocument(const std::string &name, const std::string &document) {
         continue;
       std::string text;
       collectText(*root, text);
+      // A code block never shows more lines than it ends with: a line that is
+      // only the start of the closing fence, or of its quote markers or indent,
+      // would show as a line of code and then disappear.
+      std::vector<std::string> code;
+      collectCode(*root, code);
+      for (size_t k = 0; k < code.size() && k < wholeCode.size(); k++) {
+        auto lineCount = [](const std::string &s) { return std::count(s.begin(), s.end(), '\n'); };
+        if (lineCount(code[k]) > lineCount(wholeCode[k])) {
+          std::cerr << "FAIL: " << name << (mode == StreamingBlockMode::Hidden ? " (hidden)" : "")
+                    << " shows an extra line in code block " << k << " after " << length << " bytes\n";
+          failures++;
+          break;
+        }
+      }
       std::istringstream fragments(text);
       for (std::string fragment; std::getline(fragments, fragment);) {
         if (leaksSyntax(fragment, wholeText)) {
@@ -119,6 +186,12 @@ int checkDocument(const std::string &name, const std::string &document) {
           failures++;
           break;
         }
+        if (flashesDelimiter(fragment, wholeText)) {
+          std::cerr << "FAIL: " << name << (mode == StreamingBlockMode::Hidden ? " (hidden)" : "")
+                    << " shows the start of a delimiter after " << length << " bytes: [" << fragment << "]\n";
+          failures++;
+          break;
+        }
       }
     }
   }
diff --git a/packages/core/cpp/tests/streaming_filter_test.cpp b/packages/core/cpp/tests/streaming_filter_test.cpp
index 342897829..e6d7a7a2e 100644
--- a/packages/core/cpp/tests/streaming_filter_test.cpp
+++ b/packages/core/cpp/tests/streaming_filter_test.cpp
@@ -235,17 +235,93 @@ int main() {
   expect("A\n\n```mer", "A\n\n", "a fence whose opening line has not ended waits");
   expect("A\n\n```", "A\n\n", "a bare opening fence waits for its info string");
   expect("A\n\n```mermaid\n", "A\n\n```mermaid\n", "an ended opening line shows the fence");
-  expect("> ```js", "", "a quoted opening line waits");
+  expect("> ```js", "> ", "a quoted opening line waits, its quote marker kept");
   // The line after a final newline has not streamed its `>` in yet, so it keeps a quoted fence open.
   for (const char *quotedFence : {"> ```js\n> let a\n", "> [!NOTE]\n> ```py\n> x\n", "> ```js\n", "> ```js\r\n> a\r\n"})
     check(Markdown::renderableMarkdownForStreaming(quotedFence, {}).endsInsideOpenCodeFence,
           std::string("a quoted fence stays open at a line end: ") + quotedFence);
   expect("> ```mermaid\n", "> ```mermaid\n", "a quoted fence shows once its opening line ends");
-  expect("A\n\n> ```js\n> let a\n", "A\n\n", "a quoted open fence is cut at a line end (hidden)", P, P, H);
+  expect("A\n\n> ```js\n> let a\n", "A\n\n> ", "a quoted open fence is cut at a line end (hidden)", P, P, H);
   check(filter("See [docs](https://e\n| a |\n```js") == filter("See [docs](https://e\n| a |\n```js", P, P, H),
         "a waiting fence is cut as a hidden one would be");
   check(!Markdown::renderableMarkdownForStreaming("A\n\n```mer", {}).endsInsideOpenCodeFence,
         "a waiting fence is not flagged");
+  // The first characters of a delimiter are withheld until the next one decides (#1130): the result
+  // is the one before they arrived (indent included), so they never show as prose or code and then disappear.
+  for (const char *partial : {"`", "``", "~", "~~", "   ``", "$", "  $"}) {
+    for (const char *before : {"", "Intro\n\n", "Intro\n", "- item\n\n", "> quote\n> ", "- ", "1. one\n   ", "> ",
+                               "See [docs](https://e\n"}) {
+      std::string head = before;
+      if (std::string(partial).find('$') != std::string::npos && (head == "- " || head == "1. one\n   "))
+        continue; // `$$` is read as block math only outside list items
+      std::string indent(std::string(partial).find_first_not_of(' '), ' ');
+      for (StreamingBlockMode mode : {P, H})
+        check(filter(head + partial, mode, mode, mode) == filter(head + indent, mode, mode, mode),
+              "partial delimiter [" + std::string(partial) + "] after [" + head + "] withheld");
+    }
+  }
+  expect("Intro\n\n``", "Intro\n\n", "two backticks of an opener withheld");
+  expect("Intro\n\n```", "Intro\n\n", "the third backtick hands over to the waiting opener");
+  expect("Intro\n\n``x", "Intro\n\n``x", "a character that is not a fence one releases the line");
+  expect("Intro\n\n``\n", "Intro\n\n``\n", "an ended line of backticks is text");
+  expect("Intro\n\n`code` and", "Intro\n\n`code` and", "an inline code span at a line start shows");
+  expect("Intro\n\n~~gone~~", "Intro\n\n~~gone~~", "strikethrough at a line start shows");
+  expect("Intro\n\n    ``", "Intro\n\n    ``", "four spaces of indent is indented code, not a fence");
+  expect("Intro\n\n`~", "Intro\n\n`~", "mixed fence characters are text");
+  expect("Intro\n\n$5", "Intro\n\n$5", "a dollar amount shows");
+  expect("Intro\n\nA `", "Intro\n\nA `", "a backtick after text is not a fence");
+  // The start of the closing fence waits too, instead of showing as a line of code.
+  expect("```js\nlet a\n`", "```js\nlet a\n", "first character of a closing fence withheld");
+  expect("```js\nlet a\n``", "```js\nlet a\n", "two characters of a closing fence withheld");
+  expect("```js\nlet a\n```", "```js\nlet a\n```", "a complete closing fence closes");
+  check(!Markdown::renderableMarkdownForStreaming("```js\nlet a\n```", {}).endsInsideOpenCodeFence,
+        "a complete closing fence is not flagged");
+  check(Markdown::renderableMarkdownForStreaming("```js\nlet a\n``", {}).endsInsideOpenCodeFence,
+        "a withheld closing fence is still open");
+  expect("````md\n```\n``", "````md\n```\n", "a longer fence withholds up to one short of its length");
+  expect("```js\nlet a\n~~", "```js\nlet a\n~~", "the other fence character is code");
+  expect("~~~py\nx\n~~", "~~~py\nx\n", "a tilde closing fence withheld");
+  expect("```js\nlet a\n``x", "```js\nlet a\n``x", "a line that cannot close shows as code");
+  expect("```js\nlet a\n    ``", "```js\nlet a\n    ``", "an over-indented closer prefix is code");
+  expect("> ```js\n> let a\n> ``", "> ```js\n> let a\n", "a quoted closing fence withheld");
+  expect("- ```js\n  let a\n  ``", "- ```js\n  let a\n", "a listed closing fence withheld");
+  // A fence that starts a list item or quote is cut at its marker, not at the line start, so the bullet or bar
+  // stays while the fence waits for its opening line to end (and while a hidden fence is open).
+  for (const char *prefix : {"- ", "1. ", "> ", "> - ", "- a\n  - ", "> > ", "1. one\n   - "}) {
+    std::string head = prefix;
+    for (const char *fence : {"`", "``", "```", "```js", "~~~", "````"})
+      for (StreamingBlockMode mode : {P, H})
+        check(filter(head + fence, P, P, mode) == filter(head, P, P, mode),
+              "fence [" + std::string(fence) + "] after [" + head + "] keeps its container prefix");
+    expect(head + "```js\n", head + "```js\n", "an ended opening line after [" + head + "] shows the fence");
+  }
+  expect("- ```", "- ", "a bullet that starts with a fence stays");
+  expect("1. ```", "1. ", "a numbered item that starts with a fence stays");
+  expect("> - ```", "> - ", "a quoted bullet that starts with a fence stays");
+  expect("- a\n  - ```", "- a\n  - ", "a nested bullet that starts with a fence stays");
+  expect("- ```js\n  x", "- ", "a hidden fence in a list item keeps the bullet", P, P, H);
+  expect("> ```js\n> x", "> ", "a hidden fence in a quote keeps the bar", P, P, H);
+  // Inside an open fence, a last line of only whitespace or container markers is withheld: md4c would read it as a
+  // blank line of code that then disappears when the closing fence arrives.
+  for (const char *tail : {"> ", ">", "> `", "> ``"})
+    expect(std::string("> ```js\n> x\n") + tail, "> ```js\n> x\n",
+           std::string("quoted closer [") + tail + "] withheld");
+  expect("> ```js\n> x\n> ```", "> ```js\n> x\n> ```", "a quoted closing fence closes");
+  for (const char *tail : {" ", "  ", "  `", "  ``"})
+    expect(std::string("- ```js\n  x\n") + tail, "- ```js\n  x\n",
+           std::string("listed closer [") + tail + "] withheld");
+  expect("- ```js\n  x\n  ```", "- ```js\n  x\n  ```", "a listed closing fence closes");
+  expect("1. ```js\n   x\n   ``", "1. ```js\n   x\n", "a numbered item's closer withheld");
+  expect("```js\nx\n   ", "```js\nx\n", "a whitespace-only last line of a fence withheld");
+  expect("> > ```js\n> > x\n> ", "> > ```js\n> > x\n", "a nested quote's markers still streaming in withheld");
+  check(Markdown::renderableMarkdownForStreaming("> > ```js\n> > x\n> ", {}).endsInsideOpenCodeFence,
+        "a nested quote's fence stays open while its markers stream in");
+  check(Markdown::renderableMarkdownForStreaming("> ```js\n> x\n> ", {}).endsInsideOpenCodeFence,
+        "a quoted fence stays open while its closer's line starts");
+  expect("```js\nx\n> ", "```js\nx\n> ", "a quote marker inside a top-level fence is code");
+  expect("```js\nx\n\n", "```js\nx\n\n", "an ended blank line of code shows");
+  expect("A\n\n$$\nx\n$", "A\n\n", "an open math block stays cut while its closer arrives");
+  expect("A\n\n$$\nx\n$$\n\n$", "A\n\n$$\nx\n$$\n\n", "a lone dollar after closed math withheld");
   expect("", "", "empty input");
   expect("\r\n" + img + "\r\n", "\r\n" + img + "\r\n", "CRLF: complete image kept (progressive)");
   expect("\r\n" + img + "\r\n\r", "\r\n", "CRLF: trailing CR line is blank, image still open (hidden)", H);