    // the type name must be in sync with WindowsDisassembler.BuildArguments
    public unsafe class Runnable_$ID$ : global::$WorkloadTypeName$
    {
        public static void Run(BenchmarkDotNet.Engines.IHost host, System.String benchmarkName)
        {
            BenchmarkDotNet.Autogenerated.Runnable_$ID$ instance = new BenchmarkDotNet.Autogenerated.Runnable_$ID$(); // do NOT change name "instance" (used in SmartParamameter)
            $ParamsContent$

            host.WriteLine();
            foreach (System.String infoLine in BenchmarkDotNet.Environments.BenchmarkEnvironmentInfo.GetCurrent().ToFormattedString())
            {
                host.WriteLine($"// {infoLine}");
            }
            BenchmarkDotNet.Jobs.Job job = new BenchmarkDotNet.Jobs.Job(); // use full name to avoid naming conflicts, #778
            $JobSetDefinition$;
            job.Freeze();
            host.WriteLine($"// Job: {job.DisplayInfo}");
            host.WriteLine();

            System.Collections.Generic.IEnumerable<BenchmarkDotNet.Validators.ValidationError> errors = BenchmarkDotNet.Environments.BenchmarkEnvironmentInfo.Validate(job);
            if (BenchmarkDotNet.Validators.ValidationErrorReporter.ReportIfAny(errors, host))
                return;

            BenchmarkDotNet.Engines.EngineParameters engineParameters = new BenchmarkDotNet.Engines.EngineParameters()
            {
                Host = host,
                WorkloadActionUnroll = instance.WorkloadActionUnroll,
                WorkloadActionNoUnroll = instance.WorkloadActionNoUnroll,
                Dummy1Action = instance.Dummy1,
                Dummy2Action = instance.Dummy2,
                Dummy3Action = instance.Dummy3,
                OverheadActionNoUnroll = instance.OverheadActionNoUnroll,
                OverheadActionUnroll = instance.OverheadActionUnroll,
                GlobalSetupAction = instance.globalSetupAction,
                GlobalCleanupAction = instance.globalCleanupAction,
                IterationSetupAction = instance.iterationSetupAction,
                IterationCleanupAction = instance.iterationCleanupAction,
                TargetJob = job,
                OperationsPerInvoke = $OperationsPerInvoke$,
                MeasureExtraStats = $MeasureExtraStats$,
                BenchmarkName = benchmarkName
            };

            using (BenchmarkDotNet.Engines.IEngine engine = new $EngineFactoryType$().CreateReadyToRun(engineParameters))
            {
                BenchmarkDotNet.Engines.RunResults results = engine.Run();

                host.ReportResults(results); // printing costs memory, do this after runs

                instance.__TrickTheJIT__(); // compile the method for disassembler, but without actual run of the benchmark ;)
            }
        }

        public delegate $OverheadMethodReturnTypeName$ OverheadDelegate($ArgumentsDefinition$);

        public delegate $WorkloadMethodReturnTypeModifiers$ $WorkloadMethodReturnType$ WorkloadDelegate($ArgumentsDefinition$);

        public Runnable_$ID$()
        {
            globalSetupAction = $GlobalSetupMethodName$;
            globalCleanupAction = $GlobalCleanupMethodName$;
            iterationSetupAction = $IterationSetupMethodName$;
            iterationCleanupAction = $IterationCleanupMethodName$;
            overheadDelegate = __Overhead;
            workloadDelegate = $WorkloadMethodDelegate$;
            $InitializeArgumentFields$
        }

        private System.Action globalSetupAction;
        private System.Action globalCleanupAction;
        private System.Action iterationSetupAction;
        private System.Action iterationCleanupAction;
        private BenchmarkDotNet.Autogenerated.Runnable_$ID$.OverheadDelegate overheadDelegate;
        private BenchmarkDotNet.Autogenerated.Runnable_$ID$.WorkloadDelegate workloadDelegate;
        $DeclareArgumentFields$

        // this method is used only for the disassembly diagnoser purposes
        // the goal is to get this and the benchmarked method jitted, but without executing the benchmarked method itself
        public System.Int32 NotEleven;
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        public void __TrickTheJIT__()
        {
            NotEleven = new System.Random(123).Next(0, 10);
            $DisassemblerEntryMethodName$();
        }

        private System.Int32 dummyVar;

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private void Dummy1()
        {
            @DummyUnroll@
        }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private void Dummy2()
        {
            @DummyUnroll@
        }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private void Dummy3()
        {
            @DummyUnroll@
        }

        private $OverheadMethodReturnTypeName$ __Overhead($ArgumentsDefinition$) // __ is to avoid possible name conflict
        {
            $OverheadImplementation$
        }

#if RETURNS_CONSUMABLE_$ID$

        private BenchmarkDotNet.Engines.Consumer consumer = new BenchmarkDotNet.Engines.Consumer();

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                consumer.Consume(overheadDelegate($PassArguments$));@Unroll@
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                consumer.Consume(overheadDelegate($PassArguments$));
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64  i = 0; i < invokeCount; i++)
            {
                consumer.Consume(workloadDelegate($PassArguments$)$ConsumeField$);@Unroll@
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                consumer.Consume(workloadDelegate($PassArguments$)$ConsumeField$);
            }
        }
        
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        public $WorkloadMethodReturnType$ $DisassemblerEntryMethodName$()
        {
            if (NotEleven == 11)
            {
                $LoadArguments$
                return $WorkloadMethodCall$;
            }
            
            return default($WorkloadMethodReturnType$);
        }

#elif RETURNS_NON_CONSUMABLE_STRUCT_$ID$

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $OverheadMethodReturnTypeName$ result = default($OverheadMethodReturnTypeName$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                result = overheadDelegate($PassArguments$);@Unroll@
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(result);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $OverheadMethodReturnTypeName$ result = default($OverheadMethodReturnTypeName$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                result = overheadDelegate($PassArguments$);
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(result);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $WorkloadMethodReturnType$ result = default($WorkloadMethodReturnType$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                result = workloadDelegate($PassArguments$);@Unroll@
            }
            NonGenericKeepAliveWithoutBoxing(result);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $WorkloadMethodReturnType$ result = default($WorkloadMethodReturnType$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                result = workloadDelegate($PassArguments$);
            }
            NonGenericKeepAliveWithoutBoxing(result);
        }

        // we must not simply use DeadCodeEliminationHelper.KeepAliveWithoutBoxing<T> because it's generic method
        // and stack-only types like Span<T> can not be generic type arguments http://adamsitnik.com/Span/#span-must-not-be-a-generic-type-argument
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private void NonGenericKeepAliveWithoutBoxing($WorkloadMethodReturnType$ _) { }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        public $WorkloadMethodReturnType$ $DisassemblerEntryMethodName$()
        {
            if (NotEleven == 11)
            {
                $LoadArguments$
                return $WorkloadMethodCall$;
            }
            
            return default($WorkloadMethodReturnType$);
        }

#elif RETURNS_BYREF_$ID$

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $OverheadMethodReturnTypeName$ value = default($OverheadMethodReturnTypeName$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                value = overheadDelegate($PassArguments$);@Unroll@
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(value);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $OverheadMethodReturnTypeName$ value = default($OverheadMethodReturnTypeName$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                value = overheadDelegate($PassArguments$);
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(value);
        }

        private $WorkloadMethodReturnType$ workloadDefaultValueHolder = default($WorkloadMethodReturnType$);

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            ref $WorkloadMethodReturnType$ alias = ref workloadDefaultValueHolder;
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                alias = workloadDelegate($PassArguments$);@Unroll@
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(ref alias);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            ref $WorkloadMethodReturnType$ alias = ref workloadDefaultValueHolder;
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                alias = workloadDelegate($PassArguments$);
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(ref alias);
        }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        public ref $WorkloadMethodReturnType$ $DisassemblerEntryMethodName$()
        {
            if (NotEleven == 11)
            {
                $LoadArguments$
                return ref $WorkloadMethodCall$;
            }
            
            return ref workloadDefaultValueHolder;
        }
#elif RETURNS_BYREF_READONLY_$ID$

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $OverheadMethodReturnTypeName$ value = default($OverheadMethodReturnTypeName$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                value = overheadDelegate($PassArguments$);@Unroll@
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(value);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            $OverheadMethodReturnTypeName$ value = default($OverheadMethodReturnTypeName$);
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                value = overheadDelegate($PassArguments$);
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxing(value);
        }

        private $WorkloadMethodReturnType$ workloadDefaultValueHolder = default($WorkloadMethodReturnType$);

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            ref $WorkloadMethodReturnType$ alias = ref workloadDefaultValueHolder;
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                alias = workloadDelegate($PassArguments$);@Unroll@
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxingReadonly(alias);
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            ref $WorkloadMethodReturnType$ alias = ref workloadDefaultValueHolder;
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                alias = workloadDelegate($PassArguments$);
            }
            BenchmarkDotNet.Engines.DeadCodeEliminationHelper.KeepAliveWithoutBoxingReadonly(alias);
        }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        public ref readonly $WorkloadMethodReturnType$ $DisassemblerEntryMethodName$()
        {
            if (NotEleven == 11)
            {
                $LoadArguments$
                return ref $WorkloadMethodCall$;
            }
            
            return ref workloadDefaultValueHolder;
        }
#elif RETURNS_VOID_$ID$

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                overheadDelegate($PassArguments$);@Unroll@
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void OverheadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                overheadDelegate($PassArguments$);
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                workloadDelegate($PassArguments$);@Unroll@
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(BenchmarkDotNet.Portability.CodeGenHelper.AggressiveOptimizationOption)]
        private void WorkloadActionNoUnroll(System.Int64 invokeCount)
        {
            $LoadArguments$
            for (System.Int64 i = 0; i < invokeCount; i++)
            {
                workloadDelegate($PassArguments$);
            }
        }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoOptimization | System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        public void $DisassemblerEntryMethodName$()
        {
            if (NotEleven == 11)
            {
                $LoadArguments$
                $WorkloadMethodCall$;
            }
        }
#endif // RETURNS
    }