6c:T459,/** * Represents a node in a doubly linked list. * Each node maintains references to both its predecessor and successor, * enabling bidirectional traversal through the list. */ class DoublyLinkedNode { /** The data payload stored in this node */ data: T; /** Reference to the next node in the sequence (null if this is the tail) */ next: DoublyLinkedNode | null; /** Reference to the previous node in the sequence (null if this is the head) */ prev: DoublyLinkedNode | null; constructor(data: T) { this.data = data; this.next = null; this.prev = null; } } // Example: Creating nodes and establishing links const nodeA = new DoublyLinkedNode("A"); const nodeB = new DoublyLinkedNode("B"); const nodeC = new DoublyLinkedNode("C"); // Establish forward links nodeA.next = nodeB; nodeB.next = nodeC; // Establish backward links - this is what makes it "doubly" linked nodeB.prev = nodeA; nodeC.prev = nodeB; // Now we can traverse in either direction: // Forward: A → B → C // Backward: C → B → A6d:T444,""" Represents a node in a doubly linked list. Each node maintains references to both its predecessor and successor, enabling bidirectional traversal through the list. """ from typing import TypeVar, Generic, Optional T = TypeVar('T') class DoublyLinkedNode(Generic[T]): def __init__(self, data: T): # The data payload stored in this node self.data: T = data # Reference to the next node in the sequence (None if this is the tail) self.next: Optional[DoublyLinkedNode[T]] = None # Reference to the previous node in the sequence (None if this is the head) self.prev: Optional[DoublyLinkedNode[T]] = None # Example: Creating nodes and establishing links node_a = DoublyLinkedNode("A") node_b = DoublyLinkedNode("B") node_c = DoublyLinkedNode("C") # Establish forward links node_a.next = node_b node_b.next = node_c # Establish backward links - this is what makes it "doubly" linked node_b.prev = node_a node_c.prev = node_b # Now we can traverse in either direction: # Forward: A → B → C # Backward: C → B → A6e:T496,/** * Represents a node in a doubly linked list. * Each node maintains references to both its predecessor and successor, * enabling bidirectional traversal through the list. */ public class DoublyLinkedNode { /** The data payload stored in this node */ public T data; /** Reference to the next node in the sequence (null if this is the tail) */ public DoublyLinkedNode next; /** Reference to the previous node in the sequence (null if this is the head) */ public DoublyLinkedNode prev; public DoublyLinkedNode(T data) { this.data = data; this.next = null; this.prev = null; } } // Example: Creating nodes and establishing links DoublyLinkedNode nodeA = new DoublyLinkedNode<>("A"); DoublyLinkedNode nodeB = new DoublyLinkedNode<>("B"); DoublyLinkedNode nodeC = new DoublyLinkedNode<>("C"); // Establish forward links nodeA.next = nodeB; nodeB.next = nodeC; // Establish backward links - this is what makes it "doubly" linked nodeB.prev = nodeA; nodeC.prev = nodeB; // Now we can traverse in either direction: // Forward: A → B → C // Backward: C → B → A6f:T436,/** * A doubly linked list implementation that maintains head, tail, and size. * This structure enables O(1) access to both ends and O(1) size queries. */ class DoublyLinkedList { /** Reference to the first node in the list */ private head: DoublyLinkedNode | null; /** Reference to the last node in the list */ private tail: DoublyLinkedNode | null; /** Number of nodes currently in the list */ private size: number; constructor() { this.head = null; this.tail = null; this.size = 0; } /** Returns true if the list contains no elements */ isEmpty(): boolean { return this.size === 0; } /** Returns the number of elements in the list */ getSize(): number { return this.size; } /** Returns the first node (or null if empty) */ getHead(): DoublyLinkedNode | null { return this.head; } /** Returns the last node (or null if empty) */ getTail(): DoublyLinkedNode | null { return this.tail; } }70:T475,""" A doubly linked list implementation that maintains head, tail, and size. This structure enables O(1) access to both ends and O(1) size queries. """ from typing import TypeVar, Generic, Optional T = TypeVar('T') class DoublyLinkedList(Generic[T]): def __init__(self): # Reference to the first node in the list self._head: Optional[DoublyLinkedNode[T]] = None # Reference to the last node in the list self._tail: Optional[DoublyLinkedNode[T]] = None # Number of nodes currently in the list self._size: int = 0 def is_empty(self) -> bool: """Returns True if the list contains no elements.""" return self._size == 0 def get_size(self) -> int: """Returns the number of elements in the list.""" return self._size @property def head(self) -> Optional[DoublyLinkedNode[T]]: """Returns the first node (or None if empty).""" return self._head @property def tail(self) -> Optional[DoublyLinkedNode[T]]: """Returns the last node (or None if empty).""" return self._tail71:T9b5,DOUBLY LINKED LIST STRUCTURE ============================= List Object: ┌──────────────────────────────────────────────────────────────────┐ │ head ─────────────────────────────────┐ │ │ │ │ │ tail ────────────────────────────────────────────────┐ │ │ │ │ │ │ size: 3 ▼ ▼ │ └────────────────────────────────────────┼──────────────┼──────────┘ │ │ ▼ ▼ Nodes: ┌──────────┐ ┌──────────┐ ┌──────────┐ null ◄──┤ prev │◄───┤ prev │◄───┤ prev │ ├──────────┤ ├──────────┤ ├──────────┤ │ data: A │ │ data: B │ │ data: C │ ├──────────┤ ├──────────┤ ├──────────┤ │ next ├───►│ next ├───►│ next ├──► null └──────────┘ └──────────┘ └──────────┘ ▲ ▲ │ │ HEAD TAIL KEY OBSERVATIONS: ───────────────── • Each node has pointers in BOTH directions • Head's prev pointer is null (no predecessor) • Tail's next pointer is null (no successor) • The list object maintains direct access to both ends TRAVERSAL PATHS: ──────────────── Forward: HEAD → A → B → C → null Backward: TAIL → C → B → A → null72:T418,/** * Demonstrates structural states at different list sizes. * Understanding these states is essential for correct implementations. */ // STATE 1: Empty List // head = null, tail = null, size = 0 let emptyList = new DoublyLinkedList(); console.log(emptyList.isEmpty()); // true console.log(emptyList.getHead()); // null console.log(emptyList.getTail()); // null // STATE 2: Single Element // head = node, tail = node (same reference!) // node.prev = null, node.next = null let singleList = new DoublyLinkedList(); singleList.addFirst(42); // Now: head.data = 42, head === tail // head.prev = null, head.next = null // STATE 3: Two Elements // head ≠ tail // head.next = tail, tail.prev = head // head.prev = null, tail.next = null singleList.addLast(99); // Now: head.data = 42, tail.data = 99 // head.next = tail, tail.prev = head // STATE 4: Many Elements // Standard case with internal nodes // Only head has prev = null // Only tail has next = null // All internal nodes have both prev and next pointing to valid nodes73:T883,DOUBLY LINKED LIST WITH SENTINELS ================================== ┌────────────┐ ┌──────────┐ ┌──────────┐ ┌────────────┐ NULL ◄─────────┤ SENTINEL │◄───┤ prev │◄───┤ prev │◄───┤ SENTINEL │ │ (HEAD) │ ├──────────┤ ├──────────┤ │ (TAIL) │ │ no data │ │ data: A │ │ data: B │ │ no data │ ├────────────┤ ├──────────┤ ├──────────┤ ├────────────┤ │ next ├───►│ next ├───►│ next ├───►│ next │──────► NULL └────────────┘ └──────────┘ └──────────┘ └────────────┘ EMPTY LIST WITH SENTINELS: ────────────────────────── ┌────────────┐ ┌────────────┐ NULL ◄─────────┤ SENTINEL │◄───────────────────┤ SENTINEL │ │ (HEAD) │ │ (TAIL) │ │ no data │ │ no data │ ├────────────┤ ├────────────┤ │ next ├───────────────────►│ next │──────► NULL └────────────┘ └────────────┘ • Head sentinel's prev is always null • Tail sentinel's next is always null • Real data exists only between sentinels • Sentinels are never removed65:{"json":{"id":"seed_162eb8f736a69485a68078b3cbe22496","slug":"doubly-linked-lists","category":"Data Structures & Algorithms","topic":"Doubly Linked Lists","title":"Doubly Linked Lists — Bidirectional Navigation","description":"Master the doubly linked list data structure: understand its dual-pointer architecture, explore when bidirectional traversal justifies the overhead, and learn to reason about the trade-offs between memory cost and operational flexibility.","difficulty":"INTERMEDIATE","estimatedMinutes":55,"pages":[{"id":"seed_5a275848efecf10617ffef656556b4ef","title":"Structure of a Doubly Linked List","order":0,"content":[{"id":"opening-hook","title":"Beyond One-Way Streets","content":[{"data":{"content":"You've mastered the singly linked list—a chain of nodes where each node points forward to its successor, like a one-way street through your data. You can traverse from head to tail efficiently, insert at either end, and delete nodes when you have access to their predecessors.\n\nBut what happens when you need to go *backwards*?\n\nImagine you're building a text editor. Users expect to navigate with both arrow keys—left and right. They expect undo and redo. They expect to select text by dragging in either direction. With a singly linked list representing your document, every backward operation requires starting from the beginning and traversing forward until you reach your target. For a 10,000-character document, going back one character could mean 10,000 traversal steps.\n\nThis limitation isn't theoretical—it's a fundamental constraint that makes singly linked lists unsuitable for many real-world applications."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand the complete structural anatomy of a doubly linked list. You'll grasp how dual pointers transform a linear chain into a bidirectional highway, why this architectural decision has profound implications for operations, and how to visualize and reason about doubly linked structures with clarity and precision.","variant":"info"},"type":"callout"}]},{"id":"fundamental-insight","title":"The Fundamental Insight: Nodes That Look Both Ways","content":[{"data":{"content":"The conceptual leap from singly to doubly linked lists is elegantly simple yet structurally profound: **give each node the ability to look backwards as well as forwards**.\n\nIn a singly linked list, each node contains:\n- **Data**: The value stored in the node\n- **Next pointer**: A reference to the successor node\n\nIn a doubly linked list, each node contains:\n- **Data**: The value stored in the node\n- **Next pointer**: A reference to the successor node\n- **Previous pointer**: A reference to the predecessor node\n\nThis single addition—the previous pointer—fundamentally transforms the capabilities of the data structure. It's the difference between a one-way street and a two-lane highway."},"type":"text"},{"data":{"icon":"Lightbulb","title":"The Symmetry Principle","content":"A doubly linked list exhibits **structural symmetry**: from any node, you can reach both its predecessor and its successor in O(1) time. This symmetry is not merely aesthetic—it's the foundation for all the operational advantages doubly linked lists provide.","variant":"tip"},"type":"callout"},{"data":{"content":"**Why this matters architecturally:**\n\nThe addition of a single pointer per node creates what we might call *local bidirectional awareness*. Each node becomes a waypoint that knows its position relative to both neighbors, rather than a stepping stone that only knows where to go next.\n\nThis local awareness cascades into global capabilities:\n- **Reverse traversal**: Walk from tail to head without restarting\n- **Efficient deletion**: Remove any node without needing access to its predecessor\n- **Cursor operations**: Move forward and backward through data with equal ease\n- **Window navigation**: Slide viewing windows in either direction\n\nThe previous pointer doesn't just add one capability—it unlocks an entire category of operations that were previously impossible or prohibitively expensive."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"node-anatomy","title":"Anatomy of a Doubly Linked Node","content":[{"data":{"content":"Let's examine the internal structure of a doubly linked list node with the precision it deserves. Understanding this anatomy is essential for visualizing operations, reasoning about edge cases, and implementing robust solutions.\n\n**The Three Components:**\n\nEvery doubly linked list node contains exactly three components, each with a distinct responsibility:"},"type":"text"},{"data":{"items":["**Data Field**: Stores the actual value or payload. This can be a primitive type (integer, character), a reference to a complex object, or even another data structure. The data field is the *reason* for the node's existence—the pointers exist only to organize access to this data.","**Next Pointer**: A reference to the subsequent node in the sequence. For the tail node, this pointer is null (or points to a sentinel, which we'll discuss later). The next pointer enables forward traversal and maintains the logical ordering of the list.","**Previous Pointer**: A reference to the preceding node in the sequence. For the head node, this pointer is null (or points to a sentinel). The previous pointer enables backward traversal and provides the bidirectional capability that distinguishes doubly linked lists."],"title":{"icon":"Target","text":"Node Components","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"fileName":"DoublyLinkedNode","languages":[{"code":"$6c","label":"TypeScript","value":"typescript"},{"code":"$6d","label":"Python","value":"python"},{"code":"$6e","label":"Java","value":"java"}]},"type":"code"},{"data":{"icon":"Info","title":"Memory Layout Intuition","content":"Each node in a doubly linked list occupies more memory than its singly linked counterpart. The exact overhead depends on your platform's pointer size (typically 4 bytes on 32-bit systems, 8 bytes on 64-bit systems). For a 64-bit system, each node carries an additional 8-byte overhead for the previous pointer. This cost is per-node, so it scales linearly with list size.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"list-level-structure","title":"The List-Level Structure","content":[{"data":{"content":"While individual nodes form the building blocks, the **list structure itself** manages these nodes and provides the interface for all operations. Understanding this management layer is crucial for implementing and reasoning about doubly linked lists correctly.\n\n**Essential List Properties:**\n\nA well-designed doubly linked list maintains several key properties at the list level:"},"type":"text"},{"data":{"items":["**Head Pointer**: A reference to the first node in the list. This is your entry point for forward traversal. When the list is empty, the head is null (or points to a sentinel).","**Tail Pointer**: A reference to the last node in the list. This enables O(1) access to the end of the list for append operations and backward traversal. When the list is empty, the tail is null (or points to a sentinel).","**Size/Length**: An optional but recommended counter tracking the number of nodes. Maintaining this count allows O(1) size queries without traversal."],"title":{"icon":"Target","text":"List-Level Properties","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"fileName":"DoublyLinkedList","languages":[{"code":"$6f","label":"TypeScript","value":"typescript"},{"code":"$70","label":"Python","value":"python"}]},"type":"code"},{"data":{"content":"**The Structural Invariants:**\n\nA correctly maintained doubly linked list preserves several critical invariants that must hold after every operation:\n\n1. **Bidirectional Consistency**: If node A's `next` points to node B, then node B's `prev` must point to node A. This symmetry is sacred—violating it creates a corrupted data structure.\n\n2. **Boundary Conditions**: The head's `prev` pointer is null (no predecessor exists). The tail's `next` pointer is null (no successor exists).\n\n3. **Empty List State**: When the list is empty, both `head` and `tail` are null, and `size` is zero.\n\n4. **Single Element State**: When the list contains exactly one element, `head` and `tail` point to the same node, and that node's `prev` and `next` are both null.\n\n5. **Size Accuracy**: The `size` counter accurately reflects the number of nodes in the list at all times."},"type":"text"},{"data":{"icon":"AlertCircle","title":"Invariant Violations Are Catastrophic","content":"If you ever break the bidirectional consistency invariant (A.next = B but B.prev ≠ A), your data structure becomes silently corrupted. Forward traversal will show one sequence of nodes; backward traversal will show another. This is one of the most insidious bugs in linked list implementations—always verify both directions when modifying links.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"visual-mental-model","title":"Visual Mental Model: The Chain Metaphor","content":[{"data":{"content":"To internalize doubly linked list operations, you need a clear mental model. Let's build one using the metaphor of a **physical chain with interconnected links**.\n\n**The Singly Linked Model:**\nImagine a chain where each link has a hook on one side only. You can follow the chain forward by grabbing each hook in sequence, but if you want to go backward, you must return to the start and traverse forward again.\n\n**The Doubly Linked Model:**\nNow imagine each link has hooks on *both sides*—front and back. You can grab any link and move in either direction. The chain becomes a highway with lanes going both ways.\n\n**Visualizing the Structure:**"},"type":"text"},{"data":{"fileName":"structural-visualization","languages":[{"code":"$71","label":"Diagram","value":"plaintext"}],"showLineNumbers":false},"type":"code"},{"data":{"content":"**The Critical Insight: Every Link is Bidirectional**\n\nNotice how each connection in the diagram is actually *two* separate arrows pointing in opposite directions. This isn't redundant—it's the fundamental architectural choice that enables bidirectional navigation.\n\nWhen you see:\n```\nnodeA.next = nodeB\nnodeB.prev = nodeA\n```\n\nYou're establishing a **single logical link** with **two physical pointers**. This duality is the essence of doubly linked lists. The two pointers must always agree about their relationship—if they don't, the structure is broken."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Drawing Helps","content":"When implementing doubly linked list operations, always draw the before and after states. Include both prev and next pointers for every node involved. This simple practice catches pointer manipulation errors before they become bugs. Professional engineers who work with linked structures routinely sketch diagrams—it's not a beginner's crutch, it's a professional practice.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"comparison-singly-linked","title":"Structural Comparison: Singly vs Doubly Linked","content":[{"data":{"content":"To truly understand when doubly linked lists are appropriate, you must have crystal-clear mental models of both structures and their differences. Let's examine them side by side:"},"type":"text"},{"data":{"rows":[["Pointers per Node","1 (next only)","2 (next and prev)"],["Memory per Node","data + 1 pointer","data + 2 pointers"],["Forward Traversal","Yes, from any node","Yes, from any node"],["Backward Traversal","No (requires restart from head)","Yes, from any node"],["Access to Predecessor","Requires O(n) search from head","O(1) via prev pointer"],["Deletion Complexity","O(1) if predecessor known","O(1) always (node is self-sufficient)"],["Insertion Before Node","Requires predecessor reference","Directly possible via prev"],["Implementation Complexity","Simpler (fewer pointers to manage)","More complex (maintain both pointers)"]],"caption":"Structural Comparison: Singly vs Doubly Linked Lists","headers":["Aspect","Singly Linked List","Doubly Linked List"]},"type":"table"},{"data":{"left":[{"data":{"items":["Traverse backward from a given node","Delete a node given only that node's reference","Insert before a node without its predecessor","Implement efficient cursor movement in both directions","Build undo/redo functionality naturally"],"title":{"icon":"XCircle","text":"Singly Linked: What You Can't Do Efficiently","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["O(1) backward traversal from any node","True O(1) deletion with just the node reference","O(1) insertion before any given node","Natural support for bidirectional cursor/iterator","Foundation for complex structures like deques"],"title":{"icon":"CheckCircle","text":"Doubly Linked: What You Gain","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"icon":"Info","title":"The Trade-off Is Real","content":"Doubly linked lists are not universally better than singly linked lists. They use more memory, require more careful pointer management, and introduce more opportunities for bugs. If your use case only requires forward traversal and you're memory-constrained, a singly linked list may be the superior choice. Engineering is about choosing the right tool for the specific constraints you face.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"edge-cases-boundaries","title":"Edge Cases and Boundary Conditions","content":[{"data":{"content":"The structural elegance of doubly linked lists comes with increased responsibility for handling edge cases correctly. The more pointers you manage, the more boundary conditions you must consider.\n\n**Critical Edge Cases to Master:**"},"type":"text"},{"data":{"items":["**Empty List**: Both head and tail are null. Any operation must first check for this state and handle it appropriately—typically by creating a new node that becomes both head and tail.","**Single Element**: Head and tail point to the same node. Deletion removes the only element and returns the list to empty state. The single node's prev and next are both null.","**Operation at Head**: When inserting or deleting at the head, you must update both the head pointer AND the new head's prev pointer (setting it to null).","**Operation at Tail**: When inserting or deleting at the tail, you must update both the tail pointer AND the new tail's next pointer (setting it to null).","**Two Elements**: After one deletion, you may transition from a general case to a single-element case. Both head and tail must be updated to point to the remaining node."],"title":{"icon":"AlertCircle","text":"Edge Cases Requiring Special Handling","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"fileName":"edge-case-patterns","languages":[{"code":"$72","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"icon":"AlertCircle","title":"The Single-Element Trap","content":"The most common bug in doubly linked list implementations occurs when deleting the second-to-last element. Developers often update the tail correctly but forget to also set the new tail's next pointer to null—or forget to update head when it should now equal tail. Always trace through your logic with exactly two elements in the list.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"sentinel-node-pattern","title":"The Sentinel Node Pattern (Preview)","content":[{"data":{"content":"Many production implementations of doubly linked lists employ **sentinel nodes** (also called dummy nodes) to eliminate edge cases. This is an advanced technique worth understanding at a structural level.\n\n**The Idea:**\nInstead of using null to indicate \\\"no predecessor\\\" or \\\"no successor,\\\" create permanent dummy nodes at the head and tail that never contain real data and are never removed.\n\n**The Benefits:**\n- Every real node always has both a valid prev and next pointer\n- Head operations become identical to internal operations\n- Tail operations become identical to internal operations\n- No null checks needed for prev/next in standard operations"},"type":"text"},{"data":{"fileName":"sentinel-structure","languages":[{"code":"$73","label":"Diagram","value":"plaintext"}],"showLineNumbers":false},"type":"code"},{"data":{"icon":"Lightbulb","title":"Sentinels Trade Memory for Simplicity","content":"Sentinel nodes add a small constant memory overhead (two extra nodes per list) in exchange for significantly simpler code with fewer branches. This trade-off is almost always worthwhile in practice. Many language standard library implementations use sentinels for their linked list structures.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary-path-forward","title":"Summary: The Doubly Linked Structure","content":[{"data":{"content":"We've established a comprehensive understanding of doubly linked list structure. Let's consolidate the key concepts:"},"type":"text"},{"data":{"type":"ordered","items":["**Dual-Pointer Nodes**: Each node contains data plus two pointers—next and prev—enabling bidirectional navigation.","**Structural Symmetry**: The relationship between any two adjacent nodes is represented by two pointers that must always agree (A.next = B implies B.prev = A).","**List-Level Management**: The list maintains head and tail pointers for O(1) access to both ends, plus an optional size counter.","**Boundary Conditions**: Head's prev is null, tail's next is null. These boundaries define the list's extent.","**Edge Cases**: Empty, single-element, and two-element lists require special handling in most operations.","**Sentinel Pattern**: Dummy nodes at both ends can eliminate null checks and simplify implementation."],"title":{"icon":"CheckCircle","text":"Key Structural Concepts","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that you understand the anatomy of a doubly linked list, we'll dive deeper into the mechanics of the previous and next pointers. You'll learn exactly how to manipulate these pointers during insertions, deletions, and traversals—the fundamental operations that bring this structure to life."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now have a solid mental model of doubly linked list structure. You understand the node anatomy, list-level management, key invariants, boundary conditions, and the sentinel pattern. This foundation prepares you for mastering pointer manipulation in the next page.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_8f57bde7f5022af729b183a69c4a1343","title":"Previous and Next Pointers — The Mechanics of Bidirectional Links","order":1,"content":null,"isLocked":true},{"id":"seed_8f450f113343c95b61a90ce3df93372b","title":"Advantages — Bidirectional Traversal and Easier Deletion","order":2,"content":null,"isLocked":true},{"id":"seed_ed177cdd0566957e3b4e1f90a03f3ee2","title":"Disadvantages — Extra Memory and More Pointer Maintenance","order":3,"content":null,"isLocked":true}]}}