diff --git a/TriasDev.Templify.Tests/Odt/OdtContainerTests.cs b/TriasDev.Templify.Tests/Odt/OdtContainerTests.cs
new file mode 100644
index 0000000..e161f7d
--- /dev/null
+++ b/TriasDev.Templify.Tests/Odt/OdtContainerTests.cs
@@ -0,0 +1,187 @@
+// Copyright (c) 2026 TriasDev GmbH & Co. KG
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+
+using System.Xml.Linq;
+using TriasDev.Templify.Tests.Helpers;
+
+namespace TriasDev.Templify.Tests.Odt;
+
+/// <summary>
+/// Template constructs inside nested containers (text boxes, notes, sections, nested lists, headers and
+/// footers) and the uniqueness of names and ids after loop cloning.
+/// </summary>
+public sealed class OdtContainerTests
+{
+    private static readonly XNamespace _text = OdtDocumentVerifier.Text;
+    private static readonly XNamespace _table = OdtDocumentVerifier.Table;
+    private static readonly XNamespace _draw = OdtDocumentVerifier.Draw;
+
+    private static List<Dictionary<string, object>> Items(params string[] names) =>
+        names.Select(n => new Dictionary<string, object> { ["Name"] = n }).ToList();
+
+    [Fact]
+    public void LoopCloningFramesTablesSectionsAndNotes_MakesNamesUnique()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddParagraph("{{#foreach Items}}")
+            .AddXml(
+                "<text:p>{{Name}}<draw:frame draw:name=\"Box\" text:anchor-type=\"as-char\"><draw:text-box><text:p>in box {{Name}}</text:p></draw:text-box></draw:frame>" +
+                "<text:note text:id=\"ftn1\" text:note-class=\"footnote\"><text:note-citation>1</text:note-citation><text:note-body><text:p>note {{Name}}</text:p></text:note-body></text:note></text:p>")
+            .AddXml("<table:table table:name=\"Prices\"><table:table-column/><table:table-row><table:table-cell><text:p>{{Name}}</text:p></table:table-cell></table:table-row></table:table>")
+            .AddXml("<text:section text:name=\"Details\"><text:p xml:id=\"p1\">section {{Name}}</text:p></text:section>")
+            .AddParagraph("{{/foreach}}");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = Items("a", "b", "c") });
+
+        Assert.Equal(new[] { "Box", "Box_2", "Box_3" }, output.Body.Descendants(_draw + "frame").Select(f => (string)f.Attribute(_draw + "name")!));
+        Assert.Equal(new[] { "Prices", "Prices_2", "Prices_3" }, output.Body.Descendants(_table + "table").Select(t => (string)t.Attribute(_table + "name")!));
+        Assert.Equal(new[] { "Details", "Details_2", "Details_3" }, output.Body.Descendants(_text + "section").Select(s => (string)s.Attribute(_text + "name")!));
+        Assert.Equal(new[] { "ftn1", "ftn1_2", "ftn1_3" }, output.Body.Descendants(_text + "note").Select(n => (string)n.Attribute(_text + "id")!));
+        Assert.Single(output.Body.Descendants(), e => e.Attribute(XNamespace.Xml + "id") != null);
+
+        List<string> texts = output.GetParagraphTexts();
+        Assert.Contains("in box b", texts);
+        Assert.Contains("note c", texts);
+        Assert.Contains("section a", texts);
+    }
+
+    [Fact]
+    public void UniqueNames_AvoidExistingNames()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddXml("<text:p><draw:frame draw:name=\"F_2\"/></text:p>")
+            .AddParagraph("{{#foreach Items}}")
+            .AddXml("<text:p><draw:frame draw:name=\"F\"/></text:p>")
+            .AddParagraph("{{/foreach}}");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = Items("a", "b") });
+
+        Assert.Equal(new[] { "F_2", "F", "F_3" }, output.Body.Descendants(_draw + "frame").Select(f => (string)f.Attribute(_draw + "name")!));
+    }
+
+    [Fact]
+    public void FramesInHeaderAndBody_ShareOneNameSpace()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddXml("<text:p><draw:frame draw:name=\"Logo\"/></text:p>")
+            .AddHeaderXml("<text:p><draw:frame draw:name=\"Logo\"/></text:p>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object>());
+
+        Assert.Equal("Logo", (string?)output.Body.Descendants(_draw + "frame").Single().Attribute(_draw + "name"));
+        Assert.Equal("Logo_2", (string?)output.StylesXml!.Descendants(_draw + "frame").Single().Attribute(_draw + "name"));
+    }
+
+    [Fact]
+    public void LoopInsideTextBox_IsExpanded()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder().AddXml(
+            "<text:p><draw:frame draw:name=\"F\" text:anchor-type=\"paragraph\"><draw:text-box>" +
+            "<text:p>{{#foreach Items}}</text:p><text:p>- {{Name}}</text:p><text:p>{{/foreach}}</text:p>" +
+            "</draw:text-box></draw:frame></text:p>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = Items("a", "b") });
+
+        XElement textBox = output.Body.Descendants(_draw + "text-box").Single();
+        Assert.Equal(new[] { "- a", "- b" }, textBox.Elements(_text + "p").Select(OdtDocumentVerifier.RenderText));
+    }
+
+    [Fact]
+    public void LoopInsideFootnote_IsExpanded()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder().AddXml(
+            "<text:p>Text<text:note text:id=\"n\" text:note-class=\"endnote\"><text:note-citation>i</text:note-citation><text:note-body>" +
+            "<text:p>{{#foreach Items}}</text:p><text:p>src {{Name}}</text:p><text:p>{{/foreach}}</text:p>" +
+            "</text:note-body></text:note></text:p>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = Items("a", "b") });
+
+        XElement noteBody = output.Body.Descendants(_text + "note-body").Single();
+        Assert.Equal(new[] { "src a", "src b" }, noteBody.Elements(_text + "p").Select(OdtDocumentVerifier.RenderText));
+    }
+
+    [Fact]
+    public void EmptyLoopInsideTextBox_LeavesEmptyParagraph()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder().AddXml(
+            "<text:p><draw:frame draw:name=\"F\"><draw:text-box>" +
+            "<text:p>{{#foreach Items}}</text:p><text:p>{{Name}}</text:p><text:p>{{/foreach}}</text:p>" +
+            "</draw:text-box></draw:frame></text:p>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = new List<object>() });
+
+        XElement textBox = output.Body.Descendants(_draw + "text-box").Single();
+        Assert.Single(textBox.Elements(_text + "p"));
+    }
+
+    [Fact]
+    public void LoopInsideSection_AndSectionInsideLoop_AreProcessed()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddXml("<text:section text:name=\"S\"><text:p>{{#foreach Items}}</text:p><text:p>s {{Name}}</text:p><text:p>{{/foreach}}</text:p></text:section>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = Items("a", "b") });
+
+        Assert.Equal(new[] { "s a", "s b" }, output.GetParagraphTexts());
+    }
+
+    [Fact]
+    public void NestedListItemLoopInsideListItem_IsExpanded()
+    {
+        Dictionary<string, object> data = new Dictionary<string, object>
+        {
+            ["Groups"] = new List<Dictionary<string, object>>
+            {
+                new() { ["Name"] = "G1", ["Items"] = Items("a", "b") },
+                new() { ["Name"] = "G2", ["Items"] = Items("c") },
+            },
+        };
+
+        OdtDocumentBuilder template = new OdtDocumentBuilder().AddXml(
+            "<text:list>" +
+            "<text:list-item><text:p>{{#foreach group in Groups}}</text:p></text:list-item>" +
+            "<text:list-item><text:p>{{group.Name}}</text:p><text:list>" +
+            "<text:list-item><text:p>{{#foreach item in group.Items}}</text:p></text:list-item>" +
+            "<text:list-item><text:p>{{group.Name}}.{{item.Name}}</text:p></text:list-item>" +
+            "<text:list-item><text:p>{{/foreach}}</text:p></text:list-item>" +
+            "</text:list></text:list-item>" +
+            "<text:list-item><text:p>{{/foreach}}</text:p></text:list-item>" +
+            "</text:list>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, data);
+
+        Assert.Equal(new[] { "G1", "G1.a", "G1.b", "G2", "G2.c" }, output.GetParagraphTexts());
+        Assert.Equal(2, output.Body.Element(_text + "list")!.Elements(_text + "list-item").Count());
+    }
+
+    [Fact]
+    public void TableRowLoopInFooter_IsExpanded()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddParagraph("Body")
+            .AddFooterXml(
+                "<table:table table:name=\"FooterTable\"><table:table-column/>" +
+                "<table:table-row><table:table-cell><text:p>{{#foreach Items}}</text:p></table:table-cell></table:table-row>" +
+                "<table:table-row><table:table-cell><text:p>f {{Name}}</text:p></table:table-cell></table:table-row>" +
+                "<table:table-row><table:table-cell><text:p>{{/foreach}}</text:p></table:table-cell></table:table-row>" +
+                "</table:table>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Items"] = Items("a", "b") });
+
+        Assert.Equal(new[] { "f a", "f b" }, output.GetFooterTexts());
+    }
+
+    [Fact]
+    public void ConditionalRemovingWholeHeaderContent_LeavesEmptyParagraph()
+    {
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddParagraph("Body")
+            .AddHeaderXml("<text:p>{{#if Show}}</text:p><table:table><table:table-column/><table:table-row><table:table-cell><text:p>x</text:p></table:table-cell></table:table-row></table:table><text:p>{{/if}}</text:p>");
+
+        (_, OdtDocumentVerifier output) = OdtTestHelper.Process(template, new Dictionary<string, object> { ["Show"] = false });
+
+        XElement header = output.StylesXml!.Descendants(OdtDocumentVerifier.Style + "header").Single();
+        Assert.Single(header.Elements());
+        Assert.Equal(_text + "p", header.Elements().Single().Name);
+    }
+}
diff --git a/TriasDev.Templify.Tests/Odt/OdtLibreOfficeRoundTripTests.cs b/TriasDev.Templify.Tests/Odt/OdtLibreOfficeRoundTripTests.cs
index fafa1f8..86c5108 100644
--- a/TriasDev.Templify.Tests/Odt/OdtLibreOfficeRoundTripTests.cs
+++ b/TriasDev.Templify.Tests/Odt/OdtLibreOfficeRoundTripTests.cs
@@ -176,6 +176,42 @@ public void Loops_RoundTripThroughLibreOffice()
         Assert.Equal("End", lines[^1]);
     }
 
+    [Fact]
+    public void ClonedFramesTablesAndSections_KeepTheirUniqueNamesInLibreOffice()
+    {
+        LibreOfficeRunner.RequireExecutable();
+
+        OdtDocumentBuilder template = new OdtDocumentBuilder()
+            .AddParagraph("{{#foreach Items}}")
+            .AddXml(
+                "<text:p>{{Name}}<draw:frame draw:name=\"Box\" text:anchor-type=\"as-char\" svg:width=\"4cm\" svg:height=\"1cm\">" +
+                "<draw:text-box><text:p>box {{Name}}</text:p></draw:text-box></draw:frame></text:p>")
+            .AddXml("<table:table table:name=\"Prices\"><table:table-column/><table:table-row><table:table-cell><text:p>cell {{Name}}</text:p></table:table-cell></table:table-row></table:table>")
+            .AddXml("<text:section text:name=\"Details\"><text:p>section {{Name}}</text:p></text:section>")
+            .AddParagraph("{{/foreach}}");
+
+        byte[] output = ProcessToBytes(template, new Dictionary<string, object>
+        {
+            ["Items"] = new List<Dictionary<string, object>> { new() { ["Name"] = "A" }, new() { ["Name"] = "B" } },
+        });
+
+        // Let LibreOffice load and save the document again: it keeps unique names and renames duplicates.
+        OdtDocumentVerifier resaved = new OdtDocumentVerifier(LibreOfficeRunner.Convert(output, "odt", "odt", "odt"));
+        Assert.Equal(
+            new[] { "Box", "Box_2" },
+            resaved.Body.Descendants(OdtDocumentVerifier.Draw + "frame").Select(f => (string)f.Attribute(OdtDocumentVerifier.Draw + "name")!));
+        Assert.Equal(
+            new[] { "Prices", "Prices_2" },
+            resaved.Body.Descendants(OdtDocumentVerifier.Table + "table").Select(t => (string)t.Attribute(OdtDocumentVerifier.Table + "name")!));
+        Assert.Equal(
+            new[] { "Details", "Details_2" },
+            resaved.Body.Descendants(OdtDocumentVerifier.Text + "section").Select(s => (string)s.Attribute(OdtDocumentVerifier.Text + "name")!));
+
+        string all = string.Join("\n", LibreOfficeRunner.ConvertToTextLines(output));
+        Assert.Contains("cell B", all, StringComparison.Ordinal);
+        Assert.Contains("section B", all, StringComparison.Ordinal);
+    }
+
     private static byte[] ProcessToBytes(OdtDocumentBuilder template, Dictionary<string, object> data)
     {
         OdtTemplateProcessor processor = new OdtTemplateProcessor(new PlaceholderReplacementOptions { Culture = CultureInfo.InvariantCulture });
diff --git a/TriasDev.Templify/OpenDocument/OdtTemplateEngine.cs b/TriasDev.Templify/OpenDocument/OdtTemplateEngine.cs
index 254cb7a..82c2179 100644
--- a/TriasDev.Templify/OpenDocument/OdtTemplateEngine.cs
+++ b/TriasDev.Templify/OpenDocument/OdtTemplateEngine.cs
@@ -56,13 +56,18 @@ public void Process(OdtPackage package, IEvaluationContext context)
         ProcessBlocks(body.Elements().ToList(), context);
 
         XDocument? styles = package.GetXml(OdtPackage.StylesEntry);
-        if (styles?.Root != null)
+        List<XElement> headersAndFooters = styles?.Root != null
+            ? GetHeadersAndFooters(styles.Root).ToList()
+            : new List<XElement>();
+        foreach (XElement headerOrFooter in headersAndFooters)
         {
-            foreach (XElement headerOrFooter in GetHeadersAndFooters(styles.Root))
-            {
-                ProcessContainer(headerOrFooter, context);
-            }
+            ProcessContainer(headerOrFooter, context);
         }
+
+        // Loop cloning copies frame, table and section names and note ids; make them unique again.
+        List<XElement> roots = new List<XElement> { body };
+        roots.AddRange(headersAndFooters);
+        OdtUniqueNames.EnsureUnique(roots);
     }
 
     /// <summary>
diff --git a/TriasDev.Templify/OpenDocument/OdtUniqueNames.cs b/TriasDev.Templify/OpenDocument/OdtUniqueNames.cs
new file mode 100644
index 0000000..7d3eb47
--- /dev/null
+++ b/TriasDev.Templify/OpenDocument/OdtUniqueNames.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2026 TriasDev GmbH & Co. KG
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+
+using System.Globalization;
+using System.Xml.Linq;
+
+namespace TriasDev.Templify.OpenDocument;
+
+/// <summary>
+/// Makes object names and ids unique after template processing. The OpenDocument counterpart of
+/// <c>DrawingIdAllocator</c>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Cloning loop content copies every frame, shape, table, section and note together with its name or id.
+/// ODF requires these to be unique: LibreOffice renames duplicate frames and tables on load (breaking
+/// references to them), and duplicate <c>xml:id</c> values make the document invalid.
+/// </para>
+/// <para>
+/// The pass runs once over the body and the headers and footers (<c>content.xml</c> and <c>styles.xml</c>
+/// share one name space) and changes only duplicates, so the first occurrence (usually the one the template
+/// author named and references) keeps its name. Duplicate <c>xml:id</c> values are removed from the later
+/// occurrences, since they only link RDF metadata, which belongs to the original.
+/// </para>
+/// </remarks>
+internal static class OdtUniqueNames
+{
+    private static readonly XName _xmlId = XNamespace.Xml + "id";
+    private static readonly XName _drawName = OdfNames.Draw + "name";
+    private static readonly XName _tableName = OdfNames.Table + "name";
+    private static readonly XName _textName = OdfNames.Text + "name";
+    private static readonly XName _textId = OdfNames.Text + "id";
+
+    /// <summary>
+    /// Renames duplicate frame/shape, table and section names and note ids, and removes duplicate xml:ids.
+    /// </summary>
+    public static void EnsureUnique(IReadOnlyList<XElement> roots)
+    {
+        List<XElement> elements = roots.SelectMany(r => r.DescendantsAndSelf()).ToList();
+
+        Rename(elements, e => e.Name.Namespace == OdfNames.Draw ? e.Attribute(_drawName) : null);
+        Rename(elements, e => e.Name == OdfNames.TableElement ? e.Attribute(_tableName) : null);
+        Rename(elements, e => e.Name == OdfNames.Section ? e.Attribute(_textName) : null);
+        Rename(elements, e => e.Name == OdfNames.Note ? e.Attribute(_textId) : null);
+
+        HashSet<string> xmlIds = new HashSet<string>(StringComparer.Ordinal);
+        foreach (XElement element in elements)
+        {
+            XAttribute? id = element.Attribute(_xmlId);
+            if (id != null && !xmlIds.Add(id.Value))
+            {
+                id.Remove();
+            }
+        }
+    }
+
+    private static void Rename(List<XElement> elements, Func<XElement, XAttribute?> select)
+    {
+        List<XAttribute> attributes = elements.Select(select).OfType<XAttribute>().ToList();
+        HashSet<string> used = new HashSet<string>(attributes.Select(a => a.Value), StringComparer.Ordinal);
+        HashSet<string> seen = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (XAttribute attribute in attributes)
+        {
+            if (seen.Add(attribute.Value))
+            {
+                continue;
+            }
+
+            string baseName = attribute.Value;
+            int counter = 2;
+            string candidate;
+            do
+            {
+                candidate = baseName + "_" + counter.ToString(CultureInfo.InvariantCulture);
+                counter++;
+            }
+            while (used.Contains(candidate));
+
+            used.Add(candidate);
+            seen.Add(candidate);
+            attribute.Value = candidate;
+        }
+    }
+}
diff --git a/docs/superpowers/specs/2026-09-26-odt-support-design.md b/docs/superpowers/specs/2026-09-26-odt-support-design.md
index 21267e2..fd7b9f5 100644
--- a/docs/superpowers/specs/2026-09-26-odt-support-design.md
+++ b/docs/superpowers/specs/2026-09-26-odt-support-design.md
@@ -118,7 +118,7 @@ This mirrors `DocumentWalker.WalkElements`/`WalkRows`, including the #140 rule:
 | `OdtConditionalDetector`, `OdtConditionalBlock` | block and table-row conditionals over `XElement` siblings. They reuse `ConditionalPatterns` and have the same errors and messages as `ConditionalDetector`. | 2 |
 | `OdtLoopDetector`, `OdtLoopBlock` | body, table-row and list-item loops. They reuse the `LoopDetector` patterns and name validation. | 3 |
 | `OdtLoopDetector`, `OdtLoopBlock` (row loops) | a repeated row is cloned and removed as a unit, and covered cells are cloned with their row (no separate component needed) | 3 |
-| `OdtDrawingNames` | makes `draw:name` of frames and shapes unique after cloning (the counterpart of `DrawingIdAllocator`, #178). Duplicate names make LibreOffice rename objects on load and break references. | 5 |
+| `OdtUniqueNames` | makes `draw:name` of frames and shapes, `table:name`, the `text:name` of sections and the `text:id` of notes unique after cloning, and drops duplicate `xml:id`s (the counterpart of `DrawingIdAllocator`, #178). Duplicate names make LibreOffice rename objects on load and break references. | 4 |
 | `OdtTextStyles` | the automatic-style registry per part (`content.xml` and `styles.xml` each have their own). It creates or reuses `T…` text styles for bold, italic, strikethrough and their combinations. | 5 |
 | `OdtTemplateValidator` | the ODT counterpart of `TemplateValidator` / `ScopedVariableValidator` | 5 |
 
@@ -176,8 +176,8 @@ The maintainer's list names "internal document abstraction" as step 1. Because o
 | 1 | This spec. `OdtPackage`, `OdtParagraphTextModel`, `OdtParagraphTextRewriter`, `OdtTemplateEngine` with placeholders everywhere (body, headings, tables, lists, sections, notes, text boxes, headers/footers), and the public `OdtTemplateProcessor` (process overloads). |
 | 2 | Conditionals: block (paragraph-level, across any block containers), inline (same paragraph, including elseif/else and nesting), table-row, and **list-item** (see 8.1), with the same warnings and errors. Cells, notes, text boxes and headers/footers that end up empty get an empty `text:p`. A list item left without content, and a list, table or header-row group left without items or rows, is removed. |
 | 3 | Loops: body loops with implicit and named iteration variables, metadata (`@index`, `@number`, `@first`, `@last`, `@count`), nested loops, null items and missing or null collections with warnings, and `WarnOnEmptyLoopCollections`. Table-row loops and conditionals, with repeated rows expanded and covered cells. |
-| 4 | Container integrity: list-item loops and conditionals, loops and conditionals in headers/footers, notes, text boxes and sections, empty-container fixes (a table without rows is removed, and so on), and `text:section` name uniqueness after cloning. |
-| 5 | Markdown via automatic styles, `EnableMarkdown` and `:raw`. `draw:name` uniqueness for cloned frames. `ValidateTemplate` for ODT. `DocumentProperties` → `meta.xml`. |
+| 4 | Container integrity: loops and conditionals in headers/footers, notes, text boxes, sections and nested lists, and empty-container fixes. List-item loops and conditionals shipped earlier, in PRs 2 and 3. **Name uniqueness after cloning** (`OdtUniqueNames`) covers `draw:name` of frames and shapes, `table:name`, the `text:name` of sections and the `text:id` of notes. The first occurrence keeps its name, and duplicates get `_2`, `_3`, … Duplicate `xml:id`s are removed from the later copies. Body and headers/footers share one name space. This was moved forward from PR 5. |
+| 5 | Markdown via automatic styles, `EnableMarkdown` and `:raw`. `ValidateTemplate` for ODT. `DocumentProperties` → `meta.xml`. |
 | later (lead) | The universal facade, docs and examples, converter and GUI support, and an optional LibreOffice CI job. |
 
 ## 8. Known limitations and open questions (conservative defaults chosen)
@@ -196,3 +196,4 @@ In Word a list item is just a numbered paragraph, so markers can be list paragra
 - The thumbnail (`Thumbnails/thumbnail.png`) is copied unchanged. LibreOffice regenerates it on save.
 - Indexes (table of contents) are not regenerated. Placeholders in their cached body are replaced like normal text.
 - `.fodt` is not supported (a failed result with a clear message).
+- Bookmark and annotation names cloned by loops are not renamed. They come in start/end pairs that would have to be renamed consistently. LibreOffice tolerates duplicates by renaming them on load. The same applies to DOCX, where loop-cloned bookmarks are not renamed either.