- PR comments

BorisDog · BorisDog · commit 51ae9490c8c3 · 2025-10-17T16:21:56.000-07:00
diff --git a/src/MongoDB.Bson/IO/BsonBinaryReader.cs b/src/MongoDB.Bson/IO/BsonBinaryReader.cs
@@ -32,7 +32,7 @@ public class BsonBinaryReader : BsonReader
 #pragma warning restore CA2213 // Disposable never disposed
         private readonly BsonStream _bsonStream;
         private BsonBinaryReaderContext _context;
-        private readonly Lazy<Stack<BsonBinaryReaderContext>> _contexts = new(() => new());
+        private readonly Stack<BsonBinaryReaderContext> _contexts = new(4);
 
         // constructors
         /// <summary>
@@ -113,7 +113,7 @@ public override void Close()
         /// </summary>
         /// <returns>A bookmark.</returns>
         public override BsonReaderBookmark GetBookmark() =>
-            new BsonBinaryReaderBookmark(State, CurrentBsonType, CurrentName, _context, _contexts.Value.ToArray(), _bsonStream.Position);
+            new BsonBinaryReaderBookmark(State, CurrentBsonType, CurrentName, _context, _contexts, _bsonStream.Position);
 
         /// <summary>
         /// Determines whether this reader is at end of file.
@@ -342,7 +342,7 @@ public override void ReadEndArray()
                 ThrowInvalidState("ReadEndArray", BsonReaderState.EndOfArray);
             }
 
-            _context = PopContext();
+            PopContext();
 
             switch (_context.ContextType)
             {
@@ -372,10 +372,10 @@ public override void ReadEndDocument()
                 ThrowInvalidState("ReadEndDocument", BsonReaderState.EndOfDocument);
             }
 
-            _context = PopContext();
+            PopContext();
             if (_context.ContextType == ContextType.JavaScriptWithScope)
             {
-                _context = PopContext(); // JavaScriptWithScope
+                PopContext(); // JavaScriptWithScope
             }
             switch (_context.ContextType)
             {
@@ -434,8 +434,7 @@ public override string ReadJavaScriptWithScope()
             var startPosition = _bsonStream.Position; // position of size field
             var size = ReadSize();
 
-            PushContext(_context);
-            _context = new BsonBinaryReaderContext(ContextType.JavaScriptWithScope, startPosition, size);
+            PushContext(new(ContextType.JavaScriptWithScope, startPosition, size));
 
             var code = _bsonStream.ReadString(Settings.Encoding);
 
@@ -557,7 +556,7 @@ public override IByteBuffer ReadRawBsonDocument()
 
             if (_context.ContextType == ContextType.JavaScriptWithScope)
             {
-                _context = PopContext(); // JavaScriptWithScope
+                PopContext(); // JavaScriptWithScope
             }
             switch (_context.ContextType)
             {
@@ -595,8 +594,7 @@ public override void ReadStartArray()
             var startPosition = _bsonStream.Position; // position of size field
             var size = ReadSize();
 
-            PushContext(_context);
-            _context = new(ContextType.Array, startPosition, size);
+            PushContext(new(ContextType.Array, startPosition, size));
 
             State = BsonReaderState.Type;
         }
@@ -612,8 +610,9 @@ public override void ReadStartDocument()
             var contextType = (State == BsonReaderState.ScopeDocument) ? ContextType.ScopeDocument : ContextType.Document;
             var startPosition = _bsonStream.Position; // position of size field
             var size = ReadSize();
-            PushContext(_context);
-            _context = new(contextType, startPosition, size);
+
+            PushContext(new(contextType, startPosition, size));
+
             State = BsonReaderState.Type;
         }
 
@@ -670,18 +669,11 @@ public override void ReadUndefined()
         public override void ReturnToBookmark(BsonReaderBookmark bookmark)
         {
             var binaryReaderBookmark = (BsonBinaryReaderBookmark)bookmark;
+
             State = binaryReaderBookmark.State;
             CurrentBsonType = binaryReaderBookmark.CurrentBsonType;
             CurrentName = binaryReaderBookmark.CurrentName;
-
-            _context = binaryReaderBookmark.CurrentContext;
-
-            _contexts.Value.Clear();
-            foreach (var context in binaryReaderBookmark.ContextsStack.Reverse())
-            {
-                _contexts.Value.Push(context);
-            }
-
+            _context = binaryReaderBookmark.RestoreContext(_contexts);
             _bsonStream.Position = binaryReaderBookmark.Position;
         }
 
@@ -761,7 +753,7 @@ protected override void Dispose(bool disposing)
                 {
                     Close();
                 }
-                catch { } // ignore exceptions
+                catch { /* ignore exceptions */ }
             }
             base.Dispose(disposing);
         }
@@ -790,7 +782,7 @@ private string GenerateDottedElementName()
                 elementName = "?";
             }
 
-            return GenerateDottedElementName(_contexts.Value.ToArray(), 0, elementName);
+            return GenerateDottedElementName(_contexts.ToArray(), 0, elementName);
         }
 
         private string GenerateDottedElementName(BsonBinaryReaderContext[] contexts, int currentContextIndex, string elementName)
@@ -851,20 +843,21 @@ private int ReadSize()
             return size;
         }
 
-        private BsonBinaryReaderContext PopContext()
+        private void PopContext()
         {
             var actualSize = _bsonStream.Position - _context.StartPosition;
             if (actualSize != _context.Size)
             {
                 throw new FormatException($"Expected size to be {_context.Size}, not {actualSize}.");
             }
 
-            return _contexts.Value.Pop();
+            _context =_contexts.Pop();
         }
 
-        private void PushContext(BsonBinaryReaderContext context)
+        private void PushContext(BsonBinaryReaderContext newContext)
         {
-            _contexts.Value.Push(context);
+            _contexts.Push(_context);
+            _context = newContext;
         }
     }
 }
diff --git a/src/MongoDB.Bson/IO/BsonBinaryReaderBookmark.cs b/src/MongoDB.Bson/IO/BsonBinaryReaderBookmark.cs
@@ -13,28 +13,43 @@
 * limitations under the License.
 */
 
+using System.Collections.Generic;
 namespace MongoDB.Bson.IO;
 
 /// <summary>
 /// Represents a bookmark that can be used to return a reader to the current position and state.
 /// </summary>
 public class BsonBinaryReaderBookmark : BsonReaderBookmark
 {
+    private readonly BsonBinaryReaderContext _context;
+    private readonly BsonBinaryReaderContext[] _contextArray;
+    private readonly long _position;
+
     internal BsonBinaryReaderBookmark(
         BsonReaderState state,
         BsonType currentBsonType,
         string currentName,
         BsonBinaryReaderContext currentContext,
-        BsonBinaryReaderContext[] contextsStack,
+        Stack<BsonBinaryReaderContext> contextsStack,
         long position)
         : base(state, currentBsonType, currentName)
     {
-        CurrentContext = currentContext;
-        ContextsStack = contextsStack;
-        Position = position;
+        _context = currentContext;
+        _contextArray = contextsStack.ToArray();
+        _position = position;
     }
 
-    internal BsonBinaryReaderContext CurrentContext { get; }
-    internal BsonBinaryReaderContext[] ContextsStack { get; }
-    internal long Position { get; }
+    internal long Position => _position;
+
+    internal BsonBinaryReaderContext RestoreContext(Stack<BsonBinaryReaderContext> contextStack)
+    {
+        contextStack.Clear();
+
+        for (var i = _contextArray.Length - 1; i >= 0; i--)
+        {
+            contextStack.Push(_contextArray[i]);
+        }
+
+        return _context;
+    }
 }
diff --git a/src/MongoDB.Bson/IO/BsonBinaryWriter.cs b/src/MongoDB.Bson/IO/BsonBinaryWriter.cs
@@ -30,7 +30,7 @@ public class BsonBinaryWriter : BsonWriter
 #pragma warning restore CA2213 // Disposable never disposed
         private readonly BsonStream _bsonStream;
         private BsonBinaryWriterContext _context;
-        private readonly Lazy<Stack<BsonBinaryWriterContext>> _contexts = new(() => new());
+        private readonly Stack<BsonBinaryWriterContext> _contexts = new(4);
 
         // constructors
         /// <summary>
@@ -291,7 +291,7 @@ public override void WriteEndArray()
             _bsonStream.WriteByte(0);
             BackpatchSize(); // size of document
 
-            _context = _contexts.Value.Pop();
+            PopContext();
             State = GetNextState();
         }
 
@@ -314,7 +314,7 @@ public override void WriteEndDocument()
             _bsonStream.WriteByte(0);
             BackpatchSize(); // size of document
 
-            _context = _contexts.Value.Pop();
+            PopContext();
             if (_context.ContextType == ContextType.TopLevel)
             {
                 State = BsonWriterState.Done;
@@ -324,7 +324,7 @@ public override void WriteEndDocument()
                 if (_context.ContextType == ContextType.JavaScriptWithScope)
                 {
                     BackpatchSize(); // size of the JavaScript with scope value
-                    _context = _contexts.Value.Pop();
+                    PopContext();
                 }
                 State = GetNextState();
             }
@@ -402,8 +402,7 @@ public override void WriteJavaScriptWithScope(string code)
             _bsonStream.WriteBsonType(BsonType.JavaScriptWithScope);
             WriteNameHelper();
 
-            _contexts.Value.Push(_context);
-            _context = new(ContextType.JavaScriptWithScope, _bsonStream.Position);
+            PushContext(new(ContextType.JavaScriptWithScope, _bsonStream.Position));
             _bsonStream.WriteInt32(0); // reserve space for size of JavaScript with scope value
             _bsonStream.WriteString(code, Settings.Encoding);
 
@@ -527,7 +526,7 @@ public override void WriteRawBsonDocument(IByteBuffer slice)
                 if (_context.ContextType == ContextType.JavaScriptWithScope)
                 {
                     BackpatchSize(); // size of the JavaScript with scope value
-                    _context = _contexts.Value.Pop();
+                    PopContext();
                 }
                 State = GetNextState();
             }
@@ -568,8 +567,7 @@ public override void WriteStartArray()
             _bsonStream.WriteBsonType(BsonType.Array);
             WriteNameHelper();
 
-            _contexts.Value.Push(_context);
-            _context = new(ContextType.Array, _bsonStream.Position);
+            PushContext(new(ContextType.Array, _bsonStream.Position));
             _bsonStream.WriteInt32(0); // reserve space for size
 
             State = BsonWriterState.Value;
@@ -593,8 +591,7 @@ public override void WriteStartDocument()
                 WriteNameHelper();
             }
             var contextType = (State == BsonWriterState.ScopeDocument) ? ContextType.ScopeDocument : ContextType.Document;
-            _contexts.Value.Push(_context);
-            _context = new(contextType, _bsonStream.Position);
+            PushContext(new(contextType, _bsonStream.Position));
             _bsonStream.WriteInt32(0); // reserve space for size
 
             State = BsonWriterState.Name;
@@ -687,7 +684,7 @@ protected override void Dispose(bool disposing)
                 {
                     Close();
                 }
-                catch { } // ignore exceptions
+                catch { /* ignore exceptions */ }
             }
             base.Dispose(disposing);
         }
@@ -733,5 +730,16 @@ private void WriteNameHelper()
                 _bsonStream.WriteCString(Name);
             }
         }
+
+        private void PopContext()
+        {
+            _context = _contexts.Pop();
+        }
+
+        private void PushContext(BsonBinaryWriterContext newContext)
+        {
+            _contexts.Push(_context);
+            _context = newContext;
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public class BsonBinaryReader : BsonReader`
`32`	`32`	`#pragma warning restore CA2213 // Disposable never disposed`
`33`	`33`	`private readonly BsonStream _bsonStream;`
`34`	`34`	`private BsonBinaryReaderContext _context;`
`35`		`- private readonly Lazy<Stack<BsonBinaryReaderContext>> _contexts = new(() => new());`
	`35`	`+ private readonly Stack<BsonBinaryReaderContext> _contexts = new(4);`
`36`	`36`
`37`	`37`	`// constructors`
`38`	`38`	`/// <summary>`
`@@ -113,7 +113,7 @@ public override void Close()`
`113`	`113`	`/// </summary>`
`114`	`114`	`/// <returns>A bookmark.</returns>`
`115`	`115`	`public override BsonReaderBookmark GetBookmark() =>`
`116`		`- new BsonBinaryReaderBookmark(State, CurrentBsonType, CurrentName, _context, _contexts.Value.ToArray(), _bsonStream.Position);`
	`116`	`+ new BsonBinaryReaderBookmark(State, CurrentBsonType, CurrentName, _context, _contexts, _bsonStream.Position);`
`117`	`117`
`118`	`118`	`/// <summary>`
`119`	`119`	`/// Determines whether this reader is at end of file.`
`@@ -342,7 +342,7 @@ public override void ReadEndArray()`
`342`	`342`	`ThrowInvalidState("ReadEndArray", BsonReaderState.EndOfArray);`
`343`	`343`	`}`
`344`	`344`
`345`		`- _context = PopContext();`
	`345`	`+ PopContext();`
`346`	`346`
`347`	`347`	`switch (_context.ContextType)`
`348`	`348`	`{`
`@@ -372,10 +372,10 @@ public override void ReadEndDocument()`
`372`	`372`	`ThrowInvalidState("ReadEndDocument", BsonReaderState.EndOfDocument);`
`373`	`373`	`}`
`374`	`374`
`375`		`- _context = PopContext();`
	`375`	`+ PopContext();`
`376`	`376`	`if (_context.ContextType == ContextType.JavaScriptWithScope)`
`377`	`377`	`{`
`378`		`- _context = PopContext(); // JavaScriptWithScope`
	`378`	`+ PopContext(); // JavaScriptWithScope`
`379`	`379`	`}`
`380`	`380`	`switch (_context.ContextType)`
`381`	`381`	`{`
`@@ -434,8 +434,7 @@ public override string ReadJavaScriptWithScope()`
`434`	`434`	`var startPosition = _bsonStream.Position; // position of size field`
`435`	`435`	`var size = ReadSize();`
`436`	`436`
`437`		`- PushContext(_context);`
`438`		`- _context = new BsonBinaryReaderContext(ContextType.JavaScriptWithScope, startPosition, size);`
	`437`	`+ PushContext(new(ContextType.JavaScriptWithScope, startPosition, size));`
`439`	`438`
`440`	`439`	`var code = _bsonStream.ReadString(Settings.Encoding);`
`441`	`440`
`@@ -557,7 +556,7 @@ public override IByteBuffer ReadRawBsonDocument()`
`557`	`556`
`558`	`557`	`if (_context.ContextType == ContextType.JavaScriptWithScope)`
`559`	`558`	`{`
`560`		`- _context = PopContext(); // JavaScriptWithScope`
	`559`	`+ PopContext(); // JavaScriptWithScope`
`561`	`560`	`}`
`562`	`561`	`switch (_context.ContextType)`
`563`	`562`	`{`
`@@ -595,8 +594,7 @@ public override void ReadStartArray()`
`595`	`594`	`var startPosition = _bsonStream.Position; // position of size field`
`596`	`595`	`var size = ReadSize();`
`597`	`596`
`598`		`- PushContext(_context);`
`599`		`- _context = new(ContextType.Array, startPosition, size);`
	`597`	`+ PushContext(new(ContextType.Array, startPosition, size));`
`600`	`598`
`601`	`599`	`State = BsonReaderState.Type;`
`602`	`600`	`}`
`@@ -612,8 +610,9 @@ public override void ReadStartDocument()`
`612`	`610`	`var contextType = (State == BsonReaderState.ScopeDocument) ? ContextType.ScopeDocument : ContextType.Document;`
`613`	`611`	`var startPosition = _bsonStream.Position; // position of size field`
`614`	`612`	`var size = ReadSize();`
`615`		`- PushContext(_context);`
`616`		`- _context = new(contextType, startPosition, size);`
	`613`	`+`
	`614`	`+ PushContext(new(contextType, startPosition, size));`
	`615`	`+`
`617`	`616`	`State = BsonReaderState.Type;`
`618`	`617`	`}`
`619`	`618`
`@@ -670,18 +669,11 @@ public override void ReadUndefined()`
`670`	`669`	`public override void ReturnToBookmark(BsonReaderBookmark bookmark)`
`671`	`670`	`{`
`672`	`671`	`var binaryReaderBookmark = (BsonBinaryReaderBookmark)bookmark;`
	`672`	`+`
`673`	`673`	`State = binaryReaderBookmark.State;`
`674`	`674`	`CurrentBsonType = binaryReaderBookmark.CurrentBsonType;`
`675`	`675`	`CurrentName = binaryReaderBookmark.CurrentName;`
`676`		`-`
`677`		`- _context = binaryReaderBookmark.CurrentContext;`
`678`		`-`
`679`		`- _contexts.Value.Clear();`
`680`		`- foreach (var context in binaryReaderBookmark.ContextsStack.Reverse())`
`681`		`- {`
`682`		`- _contexts.Value.Push(context);`
`683`		`- }`
`684`		`-`
	`676`	`+ _context = binaryReaderBookmark.RestoreContext(_contexts);`
`685`	`677`	`_bsonStream.Position = binaryReaderBookmark.Position;`
`686`	`678`	`}`
`687`	`679`
`@@ -761,7 +753,7 @@ protected override void Dispose(bool disposing)`
`761`	`753`	`{`
`762`	`754`	`Close();`
`763`	`755`	`}`
`764`		`- catch { } // ignore exceptions`
	`756`	`+ catch { /* ignore exceptions */ }`
`765`	`757`	`}`
`766`	`758`	`base.Dispose(disposing);`
`767`	`759`	`}`
`@@ -790,7 +782,7 @@ private string GenerateDottedElementName()`
`790`	`782`	`elementName = "?";`
`791`	`783`	`}`
`792`	`784`
`793`		`- return GenerateDottedElementName(_contexts.Value.ToArray(), 0, elementName);`
	`785`	`+ return GenerateDottedElementName(_contexts.ToArray(), 0, elementName);`
`794`	`786`	`}`
`795`	`787`
`796`	`788`	`private string GenerateDottedElementName(BsonBinaryReaderContext[] contexts, int currentContextIndex, string elementName)`
`@@ -851,20 +843,21 @@ private int ReadSize()`
`851`	`843`	`return size;`
`852`	`844`	`}`
`853`	`845`
`854`		`- private BsonBinaryReaderContext PopContext()`
	`846`	`+ private void PopContext()`
`855`	`847`	`{`
`856`	`848`	`var actualSize = _bsonStream.Position - _context.StartPosition;`
`857`	`849`	`if (actualSize != _context.Size)`
`858`	`850`	`{`
`859`	`851`	`throw new FormatException($"Expected size to be {_context.Size}, not {actualSize}.");`
`860`	`852`	`}`
`861`	`853`
`862`		`- return _contexts.Value.Pop();`
	`854`	`+ _context =_contexts.Pop();`
`863`	`855`	`}`
`864`	`856`
`865`		`- private void PushContext(BsonBinaryReaderContext context)`
	`857`	`+ private void PushContext(BsonBinaryReaderContext newContext)`
`866`	`858`	`{`
`867`		`- _contexts.Value.Push(context);`
	`859`	`+ _contexts.Push(_context);`
	`860`	`+ _context = newContext;`
`868`	`861`	`}`
`869`	`862`	`}`
`870`	`863`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public class BsonBinaryWriter : BsonWriter`
`30`	`30`	`#pragma warning restore CA2213 // Disposable never disposed`
`31`	`31`	`private readonly BsonStream _bsonStream;`
`32`	`32`	`private BsonBinaryWriterContext _context;`
`33`		`- private readonly Lazy<Stack<BsonBinaryWriterContext>> _contexts = new(() => new());`
	`33`	`+ private readonly Stack<BsonBinaryWriterContext> _contexts = new(4);`
`34`	`34`
`35`	`35`	`// constructors`
`36`	`36`	`/// <summary>`
`@@ -291,7 +291,7 @@ public override void WriteEndArray()`
`291`	`291`	`_bsonStream.WriteByte(0);`
`292`	`292`	`BackpatchSize(); // size of document`
`293`	`293`
`294`		`- _context = _contexts.Value.Pop();`
	`294`	`+ PopContext();`
`295`	`295`	`State = GetNextState();`
`296`	`296`	`}`
`297`	`297`
`@@ -314,7 +314,7 @@ public override void WriteEndDocument()`
`314`	`314`	`_bsonStream.WriteByte(0);`
`315`	`315`	`BackpatchSize(); // size of document`
`316`	`316`
`317`		`- _context = _contexts.Value.Pop();`
	`317`	`+ PopContext();`
`318`	`318`	`if (_context.ContextType == ContextType.TopLevel)`
`319`	`319`	`{`
`320`	`320`	`State = BsonWriterState.Done;`
`@@ -324,7 +324,7 @@ public override void WriteEndDocument()`
`324`	`324`	`if (_context.ContextType == ContextType.JavaScriptWithScope)`
`325`	`325`	`{`
`326`	`326`	`BackpatchSize(); // size of the JavaScript with scope value`
`327`		`- _context = _contexts.Value.Pop();`
	`327`	`+ PopContext();`
`328`	`328`	`}`
`329`	`329`	`State = GetNextState();`
`330`	`330`	`}`
`@@ -402,8 +402,7 @@ public override void WriteJavaScriptWithScope(string code)`
`402`	`402`	`_bsonStream.WriteBsonType(BsonType.JavaScriptWithScope);`
`403`	`403`	`WriteNameHelper();`
`404`	`404`
`405`		`- _contexts.Value.Push(_context);`
`406`		`- _context = new(ContextType.JavaScriptWithScope, _bsonStream.Position);`
	`405`	`+ PushContext(new(ContextType.JavaScriptWithScope, _bsonStream.Position));`
`407`	`406`	`_bsonStream.WriteInt32(0); // reserve space for size of JavaScript with scope value`
`408`	`407`	`_bsonStream.WriteString(code, Settings.Encoding);`
`409`	`408`
`@@ -527,7 +526,7 @@ public override void WriteRawBsonDocument(IByteBuffer slice)`
`527`	`526`	`if (_context.ContextType == ContextType.JavaScriptWithScope)`
`528`	`527`	`{`
`529`	`528`	`BackpatchSize(); // size of the JavaScript with scope value`
`530`		`- _context = _contexts.Value.Pop();`
	`529`	`+ PopContext();`
`531`	`530`	`}`
`532`	`531`	`State = GetNextState();`
`533`	`532`	`}`
`@@ -568,8 +567,7 @@ public override void WriteStartArray()`
`568`	`567`	`_bsonStream.WriteBsonType(BsonType.Array);`
`569`	`568`	`WriteNameHelper();`
`570`	`569`
`571`		`- _contexts.Value.Push(_context);`
`572`		`- _context = new(ContextType.Array, _bsonStream.Position);`
	`570`	`+ PushContext(new(ContextType.Array, _bsonStream.Position));`
`573`	`571`	`_bsonStream.WriteInt32(0); // reserve space for size`
`574`	`572`
`575`	`573`	`State = BsonWriterState.Value;`
`@@ -593,8 +591,7 @@ public override void WriteStartDocument()`
`593`	`591`	`WriteNameHelper();`
`594`	`592`	`}`
`595`	`593`	`var contextType = (State == BsonWriterState.ScopeDocument) ? ContextType.ScopeDocument : ContextType.Document;`
`596`		`- _contexts.Value.Push(_context);`
`597`		`- _context = new(contextType, _bsonStream.Position);`
	`594`	`+ PushContext(new(contextType, _bsonStream.Position));`
`598`	`595`	`_bsonStream.WriteInt32(0); // reserve space for size`
`599`	`596`
`600`	`597`	`State = BsonWriterState.Name;`
`@@ -687,7 +684,7 @@ protected override void Dispose(bool disposing)`
`687`	`684`	`{`
`688`	`685`	`Close();`
`689`	`686`	`}`
`690`		`- catch { } // ignore exceptions`
	`687`	`+ catch { /* ignore exceptions */ }`
`691`	`688`	`}`
`692`	`689`	`base.Dispose(disposing);`
`693`	`690`	`}`
`@@ -733,5 +730,16 @@ private void WriteNameHelper()`
`733`	`730`	`_bsonStream.WriteCString(Name);`
`734`	`731`	`}`
`735`	`732`	`}`
	`733`	`+`
	`734`	`+ private void PopContext()`
	`735`	`+ {`
	`736`	`+ _context = _contexts.Pop();`
	`737`	`+ }`
	`738`	`+`
	`739`	`+ private void PushContext(BsonBinaryWriterContext newContext)`
	`740`	`+ {`
	`741`	`+ _contexts.Push(_context);`
	`742`	`+ _context = newContext;`
	`743`	`+ }`
`736`	`744`	`}`
`737`	`745`	`}`