StackZeroingBenchmarks.cs

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using BenchmarkDotNet.Attributes;

namespace StackTests
{
    public class TestStackSizes
    {
        const int Iters = 128;

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0008() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0008_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0008_Impl() { Struct0008 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0016() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0016_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0016_Impl() { Struct0016 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0024() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0024_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0024_Impl() { Struct0024 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0032() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0032_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0032_Impl() { Struct0032 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0040() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0040_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0040_Impl() { Struct0040 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0048() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0048_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0048_Impl() { Struct0048 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0056() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0056_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0056_Impl() { Struct0056 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0064() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0064_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0064_Impl() { Struct0064 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0072() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0072_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0072_Impl() { Struct0072 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0080() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0080_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0080_Impl() { Struct0080 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0088() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0088_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0088_Impl() { Struct0088 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0096() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0096_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0096_Impl() { Struct0096 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0104() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0104_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0104_Impl() { Struct0104 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0112() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0112_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0112_Impl() { Struct0112 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0120() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0120_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0120_Impl() { Struct0120 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0128() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0128_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0128_Impl() { Struct0128 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0136() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0136_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0136_Impl() { Struct0136 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0144() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0144_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0144_Impl() { Struct0144 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0152() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0152_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0152_Impl() { Struct0152 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0160() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0160_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0160_Impl() { Struct0160 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0168() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0168_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0168_Impl() { Struct0168 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0176() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0176_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0176_Impl() { Struct0176 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0184() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0184_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0184_Impl() { Struct0184 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0192() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0192_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0192_Impl() { Struct0192 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0200() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0200_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0200_Impl() { Struct0200 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0208() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0208_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0208_Impl() { Struct0208 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0216() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0216_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0216_Impl() { Struct0216 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0224() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0224_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0224_Impl() { Struct0224 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0232() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0232_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0232_Impl() { Struct0232 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0240() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0240_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0240_Impl() { Struct0240 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0248() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0248_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0248_Impl() { Struct0248 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0256() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0256_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0256_Impl() { Struct0256 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0264() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0264_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0264_Impl() { Struct0264 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0272() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0272_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0272_Impl() { Struct0272 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0280() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0280_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0280_Impl() { Struct0280 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0288() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0288_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0288_Impl() { Struct0288 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0296() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0296_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0296_Impl() { Struct0296 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0304() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0304_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0304_Impl() { Struct0304 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0312() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0312_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0312_Impl() { Struct0312 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0320() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0320_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0320_Impl() { Struct0320 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0328() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0328_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0328_Impl() { Struct0328 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0336() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0336_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0336_Impl() { Struct0336 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0344() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0344_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0344_Impl() { Struct0344 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0352() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0352_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0352_Impl() { Struct0352 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0360() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0360_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0360_Impl() { Struct0360 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0368() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0368_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0368_Impl() { Struct0368 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0376() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0376_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0376_Impl() { Struct0376 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0384() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0384_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0384_Impl() { Struct0384 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0392() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0392_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0392_Impl() { Struct0392 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0400() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0400_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0400_Impl() { Struct0400 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0408() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0408_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0408_Impl() { Struct0408 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0416() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0416_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0416_Impl() { Struct0416 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0424() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0424_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0424_Impl() { Struct0424 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0432() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0432_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0432_Impl() { Struct0432 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0440() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0440_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0440_Impl() { Struct0440 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0448() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0448_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0448_Impl() { Struct0448 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0456() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0456_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0456_Impl() { Struct0456 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0464() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0464_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0464_Impl() { Struct0464 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0472() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0472_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0472_Impl() { Struct0472 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0480() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0480_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0480_Impl() { Struct0480 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0488() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0488_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0488_Impl() { Struct0488 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0496() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0496_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0496_Impl() { Struct0496 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0504() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0504_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0504_Impl() { Struct0504 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0512() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0512_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0512_Impl() { Struct0512 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0520() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0520_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0520_Impl() { Struct0520 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0528() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0528_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0528_Impl() { Struct0528 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0536() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0536_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0536_Impl() { Struct0536 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0544() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0544_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0544_Impl() { Struct0544 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0552() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0552_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0552_Impl() { Struct0552 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0560() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0560_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0560_Impl() { Struct0560 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0568() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0568_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0568_Impl() { Struct0568 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0576() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0576_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0576_Impl() { Struct0576 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0584() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0584_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0584_Impl() { Struct0584 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0592() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0592_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0592_Impl() { Struct0592 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0600() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0600_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0600_Impl() { Struct0600 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0608() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0608_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0608_Impl() { Struct0608 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0616() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0616_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0616_Impl() { Struct0616 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0624() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0624_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0624_Impl() { Struct0624 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0632() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0632_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0632_Impl() { Struct0632 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0640() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0640_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0640_Impl() { Struct0640 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0648() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0648_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0648_Impl() { Struct0648 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0656() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0656_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0656_Impl() { Struct0656 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0664() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0664_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0664_Impl() { Struct0664 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0672() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0672_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0672_Impl() { Struct0672 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0680() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0680_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0680_Impl() { Struct0680 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0688() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0688_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0688_Impl() { Struct0688 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0696() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0696_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0696_Impl() { Struct0696 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0704() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0704_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0704_Impl() { Struct0704 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0712() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0712_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0712_Impl() { Struct0712 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0720() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0720_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0720_Impl() { Struct0720 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0728() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0728_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0728_Impl() { Struct0728 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0736() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0736_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0736_Impl() { Struct0736 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0744() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0744_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0744_Impl() { Struct0744 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0752() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0752_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0752_Impl() { Struct0752 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0760() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0760_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0760_Impl() { Struct0760 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0768() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0768_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0768_Impl() { Struct0768 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0776() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0776_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0776_Impl() { Struct0776 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0784() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0784_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0784_Impl() { Struct0784 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0792() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0792_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0792_Impl() { Struct0792 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0800() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0800_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0800_Impl() { Struct0800 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0808() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0808_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0808_Impl() { Struct0808 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0816() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0816_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0816_Impl() { Struct0816 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0824() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0824_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0824_Impl() { Struct0824 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0832() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0832_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0832_Impl() { Struct0832 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0840() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0840_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0840_Impl() { Struct0840 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0848() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0848_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0848_Impl() { Struct0848 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0856() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0856_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0856_Impl() { Struct0856 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0864() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0864_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0864_Impl() { Struct0864 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0872() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0872_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0872_Impl() { Struct0872 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0880() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0880_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0880_Impl() { Struct0880 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0888() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0888_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0888_Impl() { Struct0888 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0896() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0896_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0896_Impl() { Struct0896 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0904() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0904_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0904_Impl() { Struct0904 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0912() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0912_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0912_Impl() { Struct0912 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0920() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0920_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0920_Impl() { Struct0920 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0928() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0928_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0928_Impl() { Struct0928 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0936() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0936_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0936_Impl() { Struct0936 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0944() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0944_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0944_Impl() { Struct0944 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0952() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0952_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0952_Impl() { Struct0952 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0960() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0960_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0960_Impl() { Struct0960 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0968() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0968_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0968_Impl() { Struct0968 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0976() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0976_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0976_Impl() { Struct0976 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0984() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0984_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0984_Impl() { Struct0984 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct0992() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct0992_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct0992_Impl() { Struct0992 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct1000() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct1000_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct1000_Impl() { Struct1000 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct1008() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct1008_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct1008_Impl() { Struct1008 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct1016() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct1016_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct1016_Impl() { Struct1016 x; return (IntPtr)(&x); }

        [Benchmark(OperationsPerInvoke = Iters)]
        public IntPtr Struct1024() 
        {
            IntPtr intPtr = default;
            for (int i = 0; i < Iters; i++)
            {
                intPtr = (IntPtr)((long)intPtr ^ (long)Struct1024_Impl());
            }

            return intPtr;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private unsafe IntPtr Struct1024_Impl() { Struct1024 x; return (IntPtr)(&x); }
    }

    [StructLayout(LayoutKind.Sequential, Size = 8)]
    public struct Struct0008
    {
        public int _length;
        public Struct0008(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 16)]
    public struct Struct0016
    {
        public int _length;
        public Struct0016(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 24)]
    public struct Struct0024
    {
        public int _length;
        public Struct0024(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 32)]
    public struct Struct0032
    {
        public int _length;
        public Struct0032(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 40)]
    public struct Struct0040
    {
        public int _length;
        public Struct0040(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 48)]
    public struct Struct0048
    {
        public int _length;
        public Struct0048(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 56)]
    public struct Struct0056
    {
        public int _length;
        public Struct0056(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 64)]
    public struct Struct0064
    {
        public int _length;
        public Struct0064(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 72)]
    public struct Struct0072
    {
        public int _length;
        public Struct0072(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 80)]
    public struct Struct0080
    {
        public int _length;
        public Struct0080(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 88)]
    public struct Struct0088
    {
        public int _length;
        public Struct0088(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 96)]
    public struct Struct0096
    {
        public int _length;
        public Struct0096(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 104)]
    public struct Struct0104
    {
        public int _length;
        public Struct0104(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 112)]
    public struct Struct0112
    {
        public int _length;
        public Struct0112(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 120)]
    public struct Struct0120
    {
        public int _length;
        public Struct0120(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 128)]
    public struct Struct0128
    {
        public int _length;
        public Struct0128(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 136)]
    public struct Struct0136
    {
        public int _length;
        public Struct0136(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 144)]
    public struct Struct0144
    {
        public int _length;
        public Struct0144(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 152)]
    public struct Struct0152
    {
        public int _length;
        public Struct0152(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 160)]
    public struct Struct0160
    {
        public int _length;
        public Struct0160(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 168)]
    public struct Struct0168
    {
        public int _length;
        public Struct0168(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 176)]
    public struct Struct0176
    {
        public int _length;
        public Struct0176(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 184)]
    public struct Struct0184
    {
        public int _length;
        public Struct0184(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 192)]
    public struct Struct0192
    {
        public int _length;
        public Struct0192(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 200)]
    public struct Struct0200
    {
        public int _length;
        public Struct0200(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 208)]
    public struct Struct0208
    {
        public int _length;
        public Struct0208(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 216)]
    public struct Struct0216
    {
        public int _length;
        public Struct0216(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 224)]
    public struct Struct0224
    {
        public int _length;
        public Struct0224(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 232)]
    public struct Struct0232
    {
        public int _length;
        public Struct0232(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 240)]
    public struct Struct0240
    {
        public int _length;
        public Struct0240(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 248)]
    public struct Struct0248
    {
        public int _length;
        public Struct0248(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 256)]
    public struct Struct0256
    {
        public int _length;
        public Struct0256(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 264)]
    public struct Struct0264
    {
        public int _length;
        public Struct0264(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 272)]
    public struct Struct0272
    {
        public int _length;
        public Struct0272(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 280)]
    public struct Struct0280
    {
        public int _length;
        public Struct0280(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 288)]
    public struct Struct0288
    {
        public int _length;
        public Struct0288(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 296)]
    public struct Struct0296
    {
        public int _length;
        public Struct0296(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 304)]
    public struct Struct0304
    {
        public int _length;
        public Struct0304(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 312)]
    public struct Struct0312
    {
        public int _length;
        public Struct0312(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 320)]
    public struct Struct0320
    {
        public int _length;
        public Struct0320(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 328)]
    public struct Struct0328
    {
        public int _length;
        public Struct0328(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 336)]
    public struct Struct0336
    {
        public int _length;
        public Struct0336(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 344)]
    public struct Struct0344
    {
        public int _length;
        public Struct0344(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 352)]
    public struct Struct0352
    {
        public int _length;
        public Struct0352(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 360)]
    public struct Struct0360
    {
        public int _length;
        public Struct0360(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 368)]
    public struct Struct0368
    {
        public int _length;
        public Struct0368(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 376)]
    public struct Struct0376
    {
        public int _length;
        public Struct0376(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 384)]
    public struct Struct0384
    {
        public int _length;
        public Struct0384(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 392)]
    public struct Struct0392
    {
        public int _length;
        public Struct0392(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 400)]
    public struct Struct0400
    {
        public int _length;
        public Struct0400(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 408)]
    public struct Struct0408
    {
        public int _length;
        public Struct0408(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 416)]
    public struct Struct0416
    {
        public int _length;
        public Struct0416(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 424)]
    public struct Struct0424
    {
        public int _length;
        public Struct0424(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 432)]
    public struct Struct0432
    {
        public int _length;
        public Struct0432(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 440)]
    public struct Struct0440
    {
        public int _length;
        public Struct0440(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 448)]
    public struct Struct0448
    {
        public int _length;
        public Struct0448(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 456)]
    public struct Struct0456
    {
        public int _length;
        public Struct0456(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 464)]
    public struct Struct0464
    {
        public int _length;
        public Struct0464(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 472)]
    public struct Struct0472
    {
        public int _length;
        public Struct0472(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 480)]
    public struct Struct0480
    {
        public int _length;
        public Struct0480(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 488)]
    public struct Struct0488
    {
        public int _length;
        public Struct0488(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 496)]
    public struct Struct0496
    {
        public int _length;
        public Struct0496(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 504)]
    public struct Struct0504
    {
        public int _length;
        public Struct0504(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 512)]
    public struct Struct0512
    {
        public int _length;
        public Struct0512(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 520)]
    public struct Struct0520
    {
        public int _length;
        public Struct0520(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 528)]
    public struct Struct0528
    {
        public int _length;
        public Struct0528(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 536)]
    public struct Struct0536
    {
        public int _length;
        public Struct0536(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 544)]
    public struct Struct0544
    {
        public int _length;
        public Struct0544(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 552)]
    public struct Struct0552
    {
        public int _length;
        public Struct0552(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 560)]
    public struct Struct0560
    {
        public int _length;
        public Struct0560(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 568)]
    public struct Struct0568
    {
        public int _length;
        public Struct0568(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 576)]
    public struct Struct0576
    {
        public int _length;
        public Struct0576(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 584)]
    public struct Struct0584
    {
        public int _length;
        public Struct0584(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 592)]
    public struct Struct0592
    {
        public int _length;
        public Struct0592(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 600)]
    public struct Struct0600
    {
        public int _length;
        public Struct0600(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 608)]
    public struct Struct0608
    {
        public int _length;
        public Struct0608(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 616)]
    public struct Struct0616
    {
        public int _length;
        public Struct0616(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 624)]
    public struct Struct0624
    {
        public int _length;
        public Struct0624(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 632)]
    public struct Struct0632
    {
        public int _length;
        public Struct0632(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 640)]
    public struct Struct0640
    {
        public int _length;
        public Struct0640(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 648)]
    public struct Struct0648
    {
        public int _length;
        public Struct0648(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 656)]
    public struct Struct0656
    {
        public int _length;
        public Struct0656(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 664)]
    public struct Struct0664
    {
        public int _length;
        public Struct0664(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 672)]
    public struct Struct0672
    {
        public int _length;
        public Struct0672(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 680)]
    public struct Struct0680
    {
        public int _length;
        public Struct0680(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 688)]
    public struct Struct0688
    {
        public int _length;
        public Struct0688(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 696)]
    public struct Struct0696
    {
        public int _length;
        public Struct0696(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 704)]
    public struct Struct0704
    {
        public int _length;
        public Struct0704(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 712)]
    public struct Struct0712
    {
        public int _length;
        public Struct0712(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 720)]
    public struct Struct0720
    {
        public int _length;
        public Struct0720(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 728)]
    public struct Struct0728
    {
        public int _length;
        public Struct0728(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 736)]
    public struct Struct0736
    {
        public int _length;
        public Struct0736(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 744)]
    public struct Struct0744
    {
        public int _length;
        public Struct0744(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 752)]
    public struct Struct0752
    {
        public int _length;
        public Struct0752(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 760)]
    public struct Struct0760
    {
        public int _length;
        public Struct0760(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 768)]
    public struct Struct0768
    {
        public int _length;
        public Struct0768(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 776)]
    public struct Struct0776
    {
        public int _length;
        public Struct0776(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 784)]
    public struct Struct0784
    {
        public int _length;
        public Struct0784(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 792)]
    public struct Struct0792
    {
        public int _length;
        public Struct0792(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 800)]
    public struct Struct0800
    {
        public int _length;
        public Struct0800(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 808)]
    public struct Struct0808
    {
        public int _length;
        public Struct0808(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 816)]
    public struct Struct0816
    {
        public int _length;
        public Struct0816(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 824)]
    public struct Struct0824
    {
        public int _length;
        public Struct0824(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 832)]
    public struct Struct0832
    {
        public int _length;
        public Struct0832(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 840)]
    public struct Struct0840
    {
        public int _length;
        public Struct0840(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 848)]
    public struct Struct0848
    {
        public int _length;
        public Struct0848(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 856)]
    public struct Struct0856
    {
        public int _length;
        public Struct0856(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 864)]
    public struct Struct0864
    {
        public int _length;
        public Struct0864(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 872)]
    public struct Struct0872
    {
        public int _length;
        public Struct0872(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 880)]
    public struct Struct0880
    {
        public int _length;
        public Struct0880(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 888)]
    public struct Struct0888
    {
        public int _length;
        public Struct0888(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 896)]
    public struct Struct0896
    {
        public int _length;
        public Struct0896(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 904)]
    public struct Struct0904
    {
        public int _length;
        public Struct0904(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 912)]
    public struct Struct0912
    {
        public int _length;
        public Struct0912(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 920)]
    public struct Struct0920
    {
        public int _length;
        public Struct0920(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 928)]
    public struct Struct0928
    {
        public int _length;
        public Struct0928(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 936)]
    public struct Struct0936
    {
        public int _length;
        public Struct0936(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 944)]
    public struct Struct0944
    {
        public int _length;
        public Struct0944(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 952)]
    public struct Struct0952
    {
        public int _length;
        public Struct0952(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 960)]
    public struct Struct0960
    {
        public int _length;
        public Struct0960(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 968)]
    public struct Struct0968
    {
        public int _length;
        public Struct0968(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 976)]
    public struct Struct0976
    {
        public int _length;
        public Struct0976(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 984)]
    public struct Struct0984
    {
        public int _length;
        public Struct0984(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 992)]
    public struct Struct0992
    {
        public int _length;
        public Struct0992(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 1000)]
    public struct Struct1000
    {
        public int _length;
        public Struct1000(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 1008)]
    public struct Struct1008
    {
        public int _length;
        public Struct1008(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 1016)]
    public struct Struct1016
    {
        public int _length;
        public Struct1016(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }


    [StructLayout(LayoutKind.Sequential, Size = 1024)]
    public struct Struct1024
    {
        public int _length;
        public Struct1024(int i) => _length = i;

        public int Length
        {
            [MethodImpl(MethodImplOptions.NoInlining)]
            get { return _length; }
        }
    }

}