ICS-SCADA-APP-WEN/Library/PackageCache/com.unity.collections/Unity.Collections/FixedStringFormat.gen.cs


//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     TextTransform Samples/Packages/com.unity.collections/Unity.Collections/FixedStringFormat.tt
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Runtime.InteropServices;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine.Internal;


namespace Unity.Collections
{
    /// <summary>
    /// Provides formatting methods for FixedString*N*.
    /// </summary>
    [GenerateTestsForBurstCompatibility]
    public static class FixedString
    {

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, int arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, float arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, string arg2, int arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, int arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, int arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, float arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, string arg2, float arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, float arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, int arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, float arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, string arg2, string arg3)

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, string arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg3 = default; carg3.Append(arg3);


            result.AppendFormat(formatString, arg0, arg1, arg2, carg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, int arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, float arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, string arg2, T1 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, arg1, carg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, T2 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, T3 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>
        /// <typeparam name="T4"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <param name="arg3">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/), typeof(FixedString32Bytes /*$T4*/) } )]
        public static FixedString512Bytes Format<T1,T2,T3,T4>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, T4 arg3)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T4 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString512Bytes result = default;


            result.AppendFormat(formatString, arg0, arg1, arg2, arg3);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1, int arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1, int arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1, float arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1, float arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1, string arg2)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, carg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, carg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1, string arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg2 = default; carg2.Append(arg2);


            result.AppendFormat(formatString, arg0, arg1, carg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, int arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, int arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, int arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, int arg1, T2 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, float arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, float arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, float arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, float arg1, T2 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, string arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, string arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, string arg1, T1 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, string arg1, T2 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, int arg0, T1 arg1, T2 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, float arg0, T1 arg1, T2 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, string arg0, T1 arg1, T2 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>
        /// <typeparam name="T3"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <param name="arg2">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
        public static FixedString128Bytes Format<T1,T2,T3>(FixedString128Bytes formatString, T1 arg0, T2 arg1, T3 arg2)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T3 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;


            result.AppendFormat(formatString, arg0, arg1, arg2);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, carg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg1 = default; carg1.Append(arg1);


            result.AppendFormat(formatString, arg0, carg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0, arg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>
        /// <typeparam name="T2"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <param name="arg1">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
        public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
            where T2 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;


            result.AppendFormat(formatString, arg0, arg1);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        
        public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [ExcludeFromBurstCompatTesting("Takes managed string")]
        public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0)

        {
            FixedString128Bytes result = default;
            FixedString32Bytes carg0 = default; carg0.Append(arg0);


            result.AppendFormat(formatString, carg0);
            return result;
        }

        /// <summary>
        /// Returns a new string produced by interpolating a format string.
        /// </summary>
        /// <remarks>
        /// Similar to StringBuilder.AppendFormat but with significant limitations:
        /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
        /// - No format modifiers (*e.g.* `{0:x}`) are supported.
        ///
        /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
        /// - FixedString*N*Bytes
        /// - string
        /// - int
        /// - float
        /// - structs implementing INativeList&lt;byte&gt; and IUTF8Bytes
        ///
        /// <seealso cref="FixedStringMethods.AppendFormat"/>
        /// </remarks>
        /// <param name="formatString">The format string.</param>
        /// <typeparam name="T1"><undoc /></typeparam>

        /// <param name="arg0">Value to interpolate into the format string.</param>
        /// <returns>A new string produced by interpolating the format string.</returns>
        [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
        public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0)
            where T1 : unmanaged, INativeList<byte>, IUTF8Bytes

        {
            FixedString128Bytes result = default;


            result.AppendFormat(formatString, arg0);
            return result;
        }

    }
}