[ShortRunJob]
    [RankColumn]
    public class Program
    {
        public static Dictionary<int, object> randomHeapAllocations = new Dictionary<int, object>();
        private static IStruct[] IStructArr = new IStruct[100000];
        private static SomeStruct[] StuctArr = new SomeStruct[100000];
        private static IClass[] IClassArr = new IClass[100000];
        private static SomeClass[] ClassArr = new SomeClass[100000];

        static Program()
        {
            for (int i = 0; i < IStructArr.Length; i++)
            {
                IStructArr[i] = new SomeStruct();
                StuctArr[i] = new SomeStruct();
                IClassArr[i] = new SomeClass();
                ClassArr[i] = new SomeClass();

                randomHeapAllocations[i] = new byte[20000];
                randomHeapAllocations[i + 100000] = new SomeStruct();
            }
        }

        [Benchmark]
        public void StuctArrNoInterface()
        {
            for (int i = 0; i < StuctArr.Length; i++)
            {
                ref var f = ref StuctArr[i];
                f.X = new Vector3(10);
            }
        }

        [Benchmark]
        public void StructArrInterfaceCast()
        {
            for (int i = 0; i < StuctArr.Length; i++)
            {
                var f = (IStruct)StuctArr[i];
                f.X = new Vector3(10);
                StuctArr[i] = (SomeStruct)f;
            }
        }

        [Benchmark]
        public void StructArrInterface()
        {
            for (int i = 0; i < IStructArr.Length; i++)
            {
                var f = IStructArr[i];
                f.X = new Vector3(10);
            }
        }

        [Benchmark]
        public void ClassArrNoInterface()
        {
            for (int i = 0; i < ClassArr.Length; i++)
            {
                ClassArr[i].X = new Vector3(10);
            }
        }

        [Benchmark]
        public void ClassArrInterfaceCast()
        {
            for (int i = 0; i < ClassArr.Length; i++)
            {
                var f = (IClass)ClassArr[i];
                f.X = new Vector3(10);
                ClassArr[i] = (SomeClass)f;
            }
        }

        [Benchmark]
        public void ClassArrInterface()
        {
            for (int i = 0; i < IClassArr.Length; i++)
            {
                IClassArr[i].X = new Vector3(10);
            }
        }

        public static void Main(string[] args)
        {
            //new Program().InterfaceCast();
            var summary = BenchmarkRunner.Run<Program>();
            //Window.OpenWindow("Zup");
            //Renderer.Init();
            //Input.Init();
            //Assets.Init();
            //Time.Init();
            //TestGame.Init();
            //GameLoop.RunGameLoop();
        }

        public interface IClass
        {
            Vector3 X { get; set; }
        }

        public class SomeClass : IClass
        {
            public Vector3 X;

            Vector3 IClass.X
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => this.X;

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                set => this.X = value;
            }
        }

        public interface IStruct
        {
            Vector3 X { get; set; }
        }

        public struct SomeStruct : IStruct
        {
            public Vector3 X;

            Vector3 IStruct.X
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => this.X;

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                set => this.X = value;
            }
        }
    }