Emit opted-in string literals into data section as UTF8 #76036

jjonescz · 2024-11-22T15:13:38Z

When this opt-in feature flag is enabled by users, string literals with length over the configured threshold are emitted into data section of the PE file, hence allowing users to overcome the "error CS8103: Combined length of user strings used by the program exceeds allowed limit."

VB support is not implemented in this PR, could be added in the future if there's demand.

I've manually tried this on our unit tests (e.g., Emit2 compiled standalone resulted in significantly smaller file size due to the use of UTF8 instead of UTF16; run time was the same; combining Emit2 and Emit3 into one assembly worked without emit errors). It was also tested on aspnetcore benchmarks and that didn't reveal any significant runtime/build perf changes.

Main motivation for this feature are Razor projects which can accumulate lots of string literals over time (due to how .razor file compilation works) and then customers are one day hit with this error without any prior warnings (imagine they are fixing a small bug and suddenly they cannot compile anymore without refactoring their codebase into multiple projects).

AlekseyTs · 2024-11-27T15:36:29Z

docs/features/string-literals-data-section.md

+error CS8103: Combined length of user strings used by the program exceeds allowed limit. Try to decrease use of string literals.
+```
+
+By turning on the feature flag `utf8-string-encoding`, string literals (where possible) are instead emitted as UTF-8 data into a different section of the PE file


utf8-string-encoding

"utf8-string-literal-encoding"? #Closed

In the spec, I've renamed it to data-section-string-literals which IMO best reflects what the feature is about.

AlekseyTs · 2024-11-27T15:37:13Z

src/Compilers/Core/Portable/CodeGen/DataStringHolder.cs

+
+namespace Microsoft.CodeAnalysis.CodeGen;
+
+internal sealed class DataStringHolder : DefaultTypeDef, Cci.INamespaceTypeDefinition


DataStringHolder

I think this type deserves a comment #Closed

AlekseyTs · 2024-11-27T15:38:41Z

src/Compilers/Core/Portable/CodeGen/DataStringHolder.cs

+
+    public DataStringHolder(
+        CommonPEModuleBuilder moduleBuilder,
+        string dataHash,


dataHash

Consider adding a comment #Closed

AlekseyTs · 2024-11-27T15:45:17Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

-        /// </param>
-        /// <returns>The field. This may have been newly created or may be an existing field previously created for the same data and alignment.</returns>
-        internal Cci.IFieldReference CreateDataField(ImmutableArray<byte> data, ushort alignment)
+        internal Cci.ITypeReference GetOrAddProxyType(int length, ushort alignment)


GetOrAddProxyType

The name looks meaningless to me. "GetOrAddDataFieldType"? #Closed

Consider renaming _proxyTypes as well

AlekseyTs · 2024-11-27T16:08:53Z

src/Compilers/Core/Portable/CodeGen/DataStringHolder.cs

+
+        Debug.Assert(_mappedFields.IsEmpty, "We need to generate unique field names if we are synthesizing more than one.");
+
+        (_, StringField stringField) = _mappedFields.GetOrAdd((data, Alignment: 1), key =>


_mappedFields

Why do we need a ConcurrentDictionary if we create at most one field? #Closed

We could have an alternative implementation strategy that has more than one field in one class. But I can simplify the code for now.

AlekseyTs · 2024-11-27T16:14:41Z

@jjonescz Please add details how do we achieve the goal: what artifacts are getting generated, what APIs are needed and how they are used, what compilation phases/layers are involved and how, etc. Basically, I think we need something like an implementation speclet for the compiler feature. #Closed

AlekseyTs · 2024-11-27T16:18:58Z

src/Compilers/Core/Portable/CodeGen/DataStringHolder.cs

+
+        fieldsBuilder.Sort(PrivateImplementationDetails.FieldComparer.Instance);
+
+        _orderedSynthesizedFields = fieldsBuilder.ToImmutableAndFree();


_orderedSynthesizedFields = fieldsBuilder.ToImmutableAndFree();

It looks like we always synthesize two fields. It feels like all the code around fieldsBuilder is unnecessary complicated. #Closed

AlekseyTs · 2024-11-27T16:28:52Z

src/Compilers/Core/Portable/CodeGen/DataStringHolder.cs

+            // Call `<PrivateImplementationDetails>.BytesToString(byte*, int)`.
+            bytesToStringHelper ??= GetOrSynthesizeBytesToStringHelper(diagnostics);
+            ilBuilder.EmitOpCode(ILOpCode.Call, -1);
+            ilBuilder.EmitToken(bytesToStringHelper, null, diagnostics);


bytesToStringHelper

Given that we only ever have one field to initialize, it doesn't feel like we need this helper method. We can simply inline what it is doing #Closed

AlekseyTs · 2024-11-27T16:31:09Z

src/Compilers/Core/Portable/CodeGen/DataStringHolder.cs

+
+namespace Microsoft.CodeAnalysis.CodeGen;
+
+internal sealed class DataStringHolder : DefaultTypeDef, Cci.INamespaceTypeDefinition


DataStringHolder

I could be missing something, but it feels like we don't really need this type. Everything what it is doing can be done by PrivateImplementationDetail #Closed

Can you elaborate?

I see there is PrivateImplementationDetails.TryAddSynthesizedType(Cci.INamespaceTypeDefinition type) which we could definitely use, hopefully simplifying some thread safety / determinism code.

But we still need a Cci.INamespaceTypeDefinition representing each generated <S> class. That's the DataStringHolder class.

AlekseyTs · 2024-11-27T16:40:34Z

I stopped reviewing the PR because I think first we need to agree on the implementation strategy and have a speclet to review against. #Closed

AlekseyTs · 2024-11-27T16:46:28Z

src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs

+        public override IEnumerable<DataStringHolder> GetFrozenDataStringHolders()
+        {
+            Debug.Assert(_lazyDataStringHolders is null || _dataStringHoldersFrozen == 1);
+            return _lazyDataStringHolders?.Values ?? SpecializedCollections.EmptyEnumerable<DataStringHolder>();


_lazyDataStringHolders?.Values

Is this going to produce items in a deterministic order? #Closed

jjonescz · 2024-11-28T11:35:52Z

@AlekseyTs thanks for the review. Sounds like a good idea to get a spec reviewed first. Opened a separate PR for that: #76139

AlekseyTs · 2024-12-05T00:31:47Z

@jjonescz The current PR title: "Add feature flag for emitting string literals into data section as UTF8" sounds like the only thing this PR is doing is adding a flag. I suggest to adjust the title to reflect the main goal/purpose of the PR, which I think is to store values of string literals as Utf-8 encoded bytes in a blob, etc. By comparison to that, the feature flag is a minor detail, which, I think, can be dropped from the title if its length becomes too big. #Closed

AlekseyTs · 2024-12-26T22:49:26Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+            this);
+        }
+
+        internal DataSectionStringType? GetOrCreateDataSectionStringLiteralType(


DataSectionStringType?

Does this function ever return null value? The name of the function implies that it doesn't.

AlekseyTs · 2024-12-26T22:52:52Z

src/Compilers/Core/Portable/CodeGen/ITokenDeferral.cs

@@ -21,6 +21,8 @@ internal interface ITokenDeferral

        Cci.IFieldReference GetArrayCachingFieldForConstants(ImmutableArray<ConstantValue> constants, Cci.IArrayTypeReference arrayType, SyntaxNode syntaxNode, DiagnosticBag diagnostics);

+        Cci.IFieldReference? GetFieldForDataString(string text, ImmutableArray<byte> data, SyntaxNode syntaxNode, DiagnosticBag diagnostics);


GetFieldForDataString

It feels like the "GetFieldForDataString" name is somewhat confusing. What is a "data string" for which we are requesting a field? It looks like we are requesting a static field that is supposed to store the value of the text parameter during at runtime. Therefore, "GetFieldForStringValue" feels better.

Also, If we expect this function to fail to produce a field under some conditions, consider adding "Try" prefix to the name of the function.

AlekseyTs · 2024-12-26T23:01:33Z

src/Compilers/Core/Portable/CodeGen/ITokenDeferral.cs

@@ -21,6 +21,8 @@ internal interface ITokenDeferral

        Cci.IFieldReference GetArrayCachingFieldForConstants(ImmutableArray<ConstantValue> constants, Cci.IArrayTypeReference arrayType, SyntaxNode syntaxNode, DiagnosticBag diagnostics);

+        Cci.IFieldReference? GetFieldForDataString(string text, ImmutableArray<byte> data, SyntaxNode syntaxNode, DiagnosticBag diagnostics);


ImmutableArray data

It looks like the data parameter is redundant. Its value is defined by content of the text parameter. Passing redundant data is a possible source of bugs because it becomes responsibility of each consumer to keep data in sync. Not to mention the fact that each consumer is responsible to do more work.

AlekseyTs · 2024-12-26T23:04:58Z

src/Compilers/Core/Portable/CodeGen/ITokenDeferral.cs

@@ -21,6 +21,8 @@ internal interface ITokenDeferral

        Cci.IFieldReference GetArrayCachingFieldForConstants(ImmutableArray<ConstantValue> constants, Cci.IArrayTypeReference arrayType, SyntaxNode syntaxNode, DiagnosticBag diagnostics);

+        Cci.IFieldReference? GetFieldForDataString(string text, ImmutableArray<byte> data, SyntaxNode syntaxNode, DiagnosticBag diagnostics);


GetFieldForDataString

It looks like this API is not consumed from any shared code. Therefore, it looks unnecessary to have it in this interface.

AlekseyTs · 2024-12-26T23:39:47Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

-            // Sort proxy types.
-            _orderedProxyTypes = _proxyTypes.OrderBy(kvp => kvp.Key.Size).ThenBy(kvp => kvp.Key.Alignment).Select(kvp => kvp.Value).AsImmutable();
+            // Sort nested types.
+            _orderedNestedTypes = _dataFieldTypes.OrderBy(kvp => kvp.Key.Size).ThenBy(kvp => kvp.Key.Alignment).Select(kvp => kvp.Value).OfType<ExplicitSizeStruct>()


.OfType()

The purpose of OfType API is to filter the input by type. I do not think that we intend to do that here. If our goal is to do a simple type cast, there is a Cast helper, but, I think it would be more efficient to perform the cast in the lambda passed to the preceding Select call.

Would it make sense to strengthen the type of values stored in _dataFieldTypes to ExplicitSizeStruct or to Cci.INestedTypeDefinition?

AlekseyTs · 2024-12-26T23:50:31Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+        /// stored and what alignment might be required.
+        /// </param>
+        /// <returns>The field. This may have been newly created or may be an existing field previously created for the same data and alignment.</returns>
+        internal MappedField CreateDataField(ImmutableArray<byte> data, ushort alignment)


MappedField

Is there a specific reason for changing return type of this function?

AlekseyTs · 2024-12-27T00:05:15Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+        {
+            _name = name;
+            _systemObject = systemObject;
+            _containingType = containingType;


_containingType

Would it make sense to use PrivateImplementationDetails for this field and get rid of the _systemObject field? Also we could avoid the need to pass systemString and bytesToStringHelper explicitly.

AlekseyTs · 2024-12-27T00:18:34Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+                if (!tryGetWellKnownTypeMember(compilation, syntaxNode, diagnostics, WellKnownMember.System_Text_Encoding__get_UTF8, out var encodingUtf8) |
+                    !tryGetWellKnownTypeMember(compilation, syntaxNode, diagnostics, WellKnownMember.System_Text_Encoding__GetString, out var encodingGetString))
+                {
+                    return new DefaultMethodDef(


return new DefaultMethodDef(

I am not sure what is going on here. Are we creating a "bogus" method definition in order to recover from an error? I think it would be preferred to not do that.

We can make it a responsibility of the only consumer of this functionality, the TryEmitStringLiteralAsUtf8Encoded, to check the presence/goodness of required APIs and to report appropriate diagnostics. In this file, we could assume that relevant APIs won't be called unless the helpers are good. I think if we do that, the logic in this file can be simplified, changes to CommonMessageProvider can be reverted, etc.

AlekseyTs · 2024-12-27T00:19:42Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+        public override bool IsSpecialName => true;
+    }
+
+    file class DefaultMethodDef(


DefaultMethodDef

I do not think we have a concept of "default method definition" and I think it would be better to not introduce one

It looks like we already have RootModuleStaticConstructor that implements Cci.IMethodDefinition, Cci.IMethodBody. Let's extract a common abstract base "MethodDefinition", rename RootModuleStaticConstructor to StaticConstructor and reuse the new base across StaticConstructor and BytesToStringHelper.

While extracting common bases, I recommend extract/copy/paste code from pre-existing types, without changing relative order of members. That is going to make code review much easier.

AlekseyTs · 2024-12-27T00:27:27Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+
+                Debug.Assert(encodingUtf8 is not null && encodingGetString is not null);
+
+                var ilBuilder = new ILBuilder(


var ilBuilder = new ILBuilder(

I think it would be better to encapsulate the IL emit logic in BytesToStringHelper type.

AlekseyTs · 2024-12-27T00:34:57Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+                WellKnownMember member,
+                [NotNullWhen(returnValue: true)] out Cci.IMethodReference? result)
+            {
+                if (compilation.CommonGetWellKnownTypeMember(member) is { } symbol)


if (compilation.CommonGetWellKnownTypeMember(member) is { } symbol)

In general, I think there is no guarantee that the symbol returned by CommonGetWellKnownTypeMember is good. We should find a way to do what Binder.GetWellKnownTypeMember is doing.

AlekseyTs · 2024-12-27T00:39:12Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

@@ -449,32 +599,40 @@ public Cci.IUnitReference GetUnit(EmitContext context)

        public string NamespaceName => string.Empty;

-        private static string DataToHex(ImmutableArray<byte> data)
+        internal static string DataToHex(ImmutableArray<byte> data)


internal

Is the accessibility change necessary?

AlekseyTs · 2024-12-27T00:40:10Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+        internal static string DataToHexViaXxHash128(ImmutableArray<byte> data)
+        {
+            Span<byte> hash = stackalloc byte[sizeof(ulong) * 2];
+            var bytesWritten = XxHash128.Hash(data.AsSpan(), hash);


var

Consider using an explicit type

AlekseyTs · 2024-12-27T00:44:46Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

@@ -484,7 +642,7 @@ static void toHex(ImmutableArray<byte> source, Span<char> destination)
            static char hexchar(int x) => (char)((x <= 9) ? (x + '0') : (x + ('A' - 10)));
        }

-        private sealed class FieldComparer : IComparer<SynthesizedStaticField>
+        internal sealed class FieldComparer : IComparer<SynthesizedStaticField>


internal

Is the accessibility change necessary?

AlekseyTs · 2024-12-27T00:45:22Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

@@ -502,7 +660,7 @@ public int Compare(SynthesizedStaticField? x, SynthesizedStaticField? y)
            }
        }

-        private sealed class DataAndUShortEqualityComparer : EqualityComparer<(ImmutableArray<byte> Data, ushort Value)>
+        internal sealed class DataAndUShortEqualityComparer : EqualityComparer<(ImmutableArray<byte> Data, ushort Value)>


internal

Is the accessibility change necessary?

AlekseyTs · 2024-12-27T00:54:29Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+    ///
+    /// https://github.com/dotnet/roslyn/blob/main/docs/features/string-literals-data-section.md
+    /// </summary>
+    internal sealed class DataSectionStringType : DefaultTypeDef, Cci.INestedTypeDefinition


DefaultTypeDef

I think it would be good to extract a common abstract base "NestedTypeDefinition" to share across ExplicitSizeStruct and DataSectionStringType

AlekseyTs · 2024-12-27T00:59:20Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+            var staticConstructor = synthesizeStaticConstructor(module, containingType, dataField, stringField, bytesToStringHelper, diagnostics);
+
+            _field = stringField;
+            _fields = [_field];


_field

It looks like the _field is redundant, we can get its value from _fields

AlekseyTs · 2024-12-27T01:04:07Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+            this);
+        }
+
+        internal DataSectionStringType? GetOrCreateDataSectionStringLiteralType(


GetOrCreateDataSectionStringLiteralType

It doesn't look like anyone is interested in the type. The only consumer is interested in a field. I think we need to adjust this API accordingly.

AlekseyTs · 2024-12-27T01:27:48Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

@@ -911,4 +1158,192 @@ public sealed override int GetHashCode()
            throw Roslyn.Utilities.ExceptionUtilities.Unreachable();
        }
    }
+
+    /// <summary>
+    /// A helper method used in static constructor of <see cref="DataSectionStringType"/>.


A helper method used in static constructor of .

I think it would be good to include information what signature this method is supposed to have.

AlekseyTs · 2024-12-27T01:39:13Z

src/Compilers/Core/Portable/CodeGen/PrivateImplementationDetails.cs

+        public override Cci.ITypeReference GetType(EmitContext context) => context.Module.GetPlatformType(_type, context);
+    }
+
+    file abstract class ParameterDefinitionBase(


ParameterDefinitionBase

Consider whether there is a benefit in extracting and sharing a common base with ReturnValueParameter.

AlekseyTs · 2024-12-27T01:45:48Z

src/Compilers/Core/Portable/Emit/CommonPEModuleBuilder.cs

@@ -1088,6 +1095,7 @@ internal PrivateImplementationDetails GetPrivateImplClass(TSyntaxNode syntaxNode
                        this.GetSpecialType(SpecialType.System_Int16, syntaxNodeOpt, diagnostics),
                        this.GetSpecialType(SpecialType.System_Int32, syntaxNodeOpt, diagnostics),
                        this.GetSpecialType(SpecialType.System_Int64, syntaxNodeOpt, diagnostics),
+                        this.GetSpecialType(SpecialType.System_String, syntaxNodeOpt, diagnostics),


this.GetSpecialType(SpecialType.System_String, syntaxNodeOpt, diagnostics),

Let's say we have a program that utilizes a private implementation detail class, but doesn't use string type, and the string type is not defined. Is this code going to break such a program?

AlekseyTs · 2024-12-27T01:47:04Z

src/Compilers/Core/Portable/PEWriter/Members.cs

@@ -415,7 +415,7 @@ ImmutableArray<ExceptionHandlerRegion> ExceptionRegions
        /// <summary>
        /// Debugging information associated with a MoveNext method of a state machine.
        /// </summary>
-        StateMachineMoveNextBodyDebugInfo MoveNextBodyInfo { get; }
+        StateMachineMoveNextBodyDebugInfo? MoveNextBodyInfo { get; }


StateMachineMoveNextBodyDebugInfo? MoveNextBodyInfo { get; }

Are changes in this file primarily related to the goal of the PR?

AlekseyTs · 2024-12-27T01:52:20Z

src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs

@@ -101,6 +104,7 @@ public CodeGenerator(
            _builder = builder;
            _module = moduleBuilder;
            _diagnostics = diagnostics;
+            _dataSectionStringLiteralThreshold = compilation.DataSectionStringLiteralThreshold;


_dataSectionStringLiteralThreshold = compilation.DataSectionStringLiteralThreshold;

Would it make sense to cache this information on the Compilation instead?

AlekseyTs · 2024-12-27T01:52:50Z

src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs

@@ -87,7 +89,8 @@ public CodeGenerator(
            PEModuleBuilder moduleBuilder,
            BindingDiagnosticBag diagnostics,
            OptimizationLevel optimizations,
-            bool emittingPdb)
+            bool emittingPdb,
+            Compilation compilation)


Compilation compilation

It looks like Compilation is available from PEModuleBuilder

AlekseyTs · 2024-12-27T02:02:22Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs

        {
-            var utf8 = new System.Text.UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);


var utf8 = new System.Text.UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

Is there a specific reason behind caching this value? Would it make sense to initialize the cache on demand rather than using a field initializer?

AlekseyTs · 2024-12-27T02:25:52Z

Done with review pass (commit 2), tests are not looked at.

dotnet-issue-labeler bot added Area-Compilers untriaged Issues and PRs which have not yet been triaged by a lead labels Nov 22, 2024

jjonescz force-pushed the DataSectionStringLiterals branch from 16f5293 to 43aa343 Compare November 22, 2024 16:42

Add feature flag for emitting string literals into data section as UTF8

e9e701d

jjonescz force-pushed the DataSectionStringLiterals branch from 43aa343 to e9e701d Compare November 25, 2024 13:45

jjonescz marked this pull request as ready for review November 25, 2024 15:25

jjonescz requested a review from a team as a code owner November 25, 2024 15:25

AlekseyTs reviewed Nov 27, 2024

View reviewed changes

jjonescz mentioned this pull request Nov 28, 2024

Add spec for the data section string literals feature #76139

Open

jjonescz marked this pull request as draft November 28, 2024 12:11

jjonescz added the Feature - String Literals in Data Section as UTF8 label Dec 3, 2024

jjonescz mentioned this pull request Dec 3, 2024

Test plan for "string literals in data section as utf8" #76234

Open

jjonescz changed the title ~~Add feature flag for emitting string literals into data section as UTF8~~ Emit opted-in string literals into data section as UTF8 Dec 5, 2024

Address feedback

b89fbb8

jjonescz marked this pull request as ready for review December 25, 2024 10:24

AlekseyTs reviewed Dec 26, 2024

View reviewed changes

AlekseyTs reviewed Dec 27, 2024

View reviewed changes


		namespace Microsoft.CodeAnalysis.CodeGen;

		internal sealed class DataStringHolder : DefaultTypeDef, Cci.INamespaceTypeDefinition


		Debug.Assert(_mappedFields.IsEmpty, "We need to generate unique field names if we are synthesizing more than one.");

		(_, StringField stringField) = _mappedFields.GetOrAdd((data, Alignment: 1), key =>


		fieldsBuilder.Sort(PrivateImplementationDetails.FieldComparer.Instance);

		_orderedSynthesizedFields = fieldsBuilder.ToImmutableAndFree();

		@@ -21,6 +21,8 @@ internal interface ITokenDeferral

		Cci.IFieldReference GetArrayCachingFieldForConstants(ImmutableArray<ConstantValue> constants, Cci.IArrayTypeReference arrayType, SyntaxNode syntaxNode, DiagnosticBag diagnostics);

		Cci.IFieldReference? GetFieldForDataString(string text, ImmutableArray<byte> data, SyntaxNode syntaxNode, DiagnosticBag diagnostics);


		Debug.Assert(encodingUtf8 is not null && encodingGetString is not null);

		var ilBuilder = new ILBuilder(

Emit opted-in string literals into data section as UTF8 #76036

Are you sure you want to change the base?

Emit opted-in string literals into data section as UTF8 #76036

Conversation

jjonescz commented Nov 22, 2024 • edited Loading

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

jjonescz Nov 28, 2024 • edited Loading

Choose a reason for hiding this comment

AlekseyTs commented Nov 27, 2024 • edited Loading

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

jjonescz Nov 28, 2024 • edited Loading

Choose a reason for hiding this comment

AlekseyTs commented Nov 27, 2024 • edited Loading

AlekseyTs Nov 27, 2024 • edited Loading

Choose a reason for hiding this comment

jjonescz commented Nov 28, 2024

AlekseyTs commented Dec 5, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs commented Dec 27, 2024

jjonescz commented Nov 22, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

jjonescz Nov 28, 2024 •

edited

Loading

AlekseyTs commented Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

jjonescz Nov 28, 2024 •

edited

Loading

AlekseyTs commented Nov 27, 2024 •

edited

Loading

AlekseyTs Nov 27, 2024 •

edited

Loading

AlekseyTs commented Dec 5, 2024 •

edited

Loading