// <auto-generated/>
// Ariadne.Generator's copy of the scripts in this file: the code that actually runs. Edits here are overwritten.
// In the copy beside the script, #line paths are relative to it; the compiled code uses full paths.
#pragma warning disable


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionBase
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Frame
        {
            public int Run__count;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<int>("Run.count");
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        protected CollisionBase()
        {
        }

        protected CollisionBase(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("BaseNote", out string loaded)) { this.BaseNote = loaded; } }
        }

        protected CollisionBase(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("BaseNote");
            lister.Local<int>("Run.count");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 8 "RunCollisionScripts.cs"
                      writer.Field<string>("BaseNote", this.BaseNote);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 12 "RunCollisionScripts.cs"
                writer.Local<int>("Run.count", this.Run__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<int>("Run.count", out int loaded)) { this.Run__count = loaded; } }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref int count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "basewait": goto basewait;
            }
#line 12 "RunCollisionScripts.cs"
            count = 1;
#line hidden
            basewait:
#line 15 "RunCollisionScripts.cs"
            while (!gates.Open.Contains("go"))
#line hidden
            {
#line 17 "RunCollisionScripts.cs"
                __frame.Mark("basewait"); return false;
#line hidden
            }
#line 20 "RunCollisionScripts.cs"
            BaseNote = "base " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "basewait":
                    __frame.SaveLocal("Run.count", writer);
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionDerived
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame
        {
            public string Run__count;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(lister);
                lister.Local<string>("Run.count");
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionDerived()
        {
        }

        protected CollisionDerived(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected CollisionDerived(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("Note");
            lister.Local<string>("Run.count");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 29 "RunCollisionScripts.cs"
                      writer.Field<string>("Note", this.Note);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 33 "RunCollisionScripts.cs"
                   writer.Local<string>("Run.count", this.Run__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<string>("Run.count", out string loaded)) { this.Run__count = loaded; } }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref string count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "derivedwait": goto derivedwait;
            }
#line 33 "RunCollisionScripts.cs"
            count = "a";
#line hidden
            derivedwait:
#line 36 "RunCollisionScripts.cs"
            while (!gates.Open.Contains("go"))
#line hidden
            {
#line 38 "RunCollisionScripts.cs"
                __frame.Mark("derivedwait"); return false;
#line hidden
            }
#line 41 "RunCollisionScripts.cs"
            Note = "derived " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "derivedwait":
                    __frame.SaveLocal("Run.count", writer);
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionCaller
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame
        {
            public string Run__count;

            public global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame Run____call_Run_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(lister);
                lister.Local<string>("Run.count");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                    }
                }
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionCaller()
        {
        }

        protected CollisionCaller(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected CollisionCaller(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("Note");
            lister.Local<string>("Run.count");
            {
                global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                if (scope != null)
                {
                    global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                }
            }
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 50 "RunCollisionScripts.cs"
                      writer.Field<string>("Note", this.Note);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 54 "RunCollisionScripts.cs"
                   writer.Local<string>("Run.count", this.Run__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<string>("Run.count", out string loaded)) { this.Run__count = loaded; } }
                {
                    if (reader.TryScope("Run.Run/", out global::Ariadne.IArcReader scope))
                    {
                        this.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame();
                        this.Run____call_Run_frame.LoadLocals(scope);
                    }
                }

            }

            public override void AttachWaits(global::Ariadne.WakeSlot slot)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.AttachWaits(slot);
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.AttachWaits(slot); }
            }

            public override void EndWaits()
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.EndWaits();
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.EndWaits(); }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref string count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "before": goto before;
                case "Run": goto Run;
            }
#line 54 "RunCollisionScripts.cs"
            count = "a";
#line hidden
            before:
#line 57 "RunCollisionScripts.cs"
            while (!gates.Open.Contains("start"))
#line hidden
            {
#line 59 "RunCollisionScripts.cs"
                __frame.Mark("before"); return false;
#line hidden
            }
#line hidden
            Run:
#line 62 "RunCollisionScripts.cs"
            using (__frame.Enter("Run")) { if (__frame.Run____call_Run_frame == null) { __frame.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame(); } if (!base.Run__Passage(__frame.Lend(__frame.Run____call_Run_frame), __time, gates)) { return false; } }
#line 63 "RunCollisionScripts.cs"
            Note = "derived " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "before":
                    __frame.SaveLocal("Run.count", writer);
                    break;
                case "Run":
                    __frame.SaveLocal("Run.count", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Run.Run/"); base.Run__LocalsToSave(__frame.Lend(__frame.Run____call_Run_frame), depth + 1, scope); }
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionLabelled
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame
        {
            public global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame Run____call_again_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(lister);
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Run.again/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                    }
                }
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionLabelled()
        {
        }

        protected CollisionLabelled(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
        }

        protected CollisionLabelled(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            {
                global::Ariadne.IArcPartLister scope = lister.Scope("Run.again/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                if (scope != null)
                {
                    global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                }
            }
        }

#pragma warning restore
#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                {
                    if (reader.TryScope("Run.again/", out global::Ariadne.IArcReader scope))
                    {
                        this.Run____call_again_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame();
                        this.Run____call_again_frame.LoadLocals(scope);
                    }
                }

            }

            public override void AttachWaits(global::Ariadne.WakeSlot slot)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.AttachWaits(slot);
                if (this.Run____call_again_frame != null) { this.Run____call_again_frame.AttachWaits(slot); }
            }

            public override void EndWaits()
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.EndWaits();
                if (this.Run____call_again_frame != null) { this.Run____call_again_frame.EndWaits(); }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            switch (__frame.ResumeKey)
            {
                case "again": goto again;
            }
#line hidden
            again:
#line 75 "RunCollisionScripts.cs"
            using (__frame.Enter("again")) { if (__frame.Run____call_again_frame == null) { __frame.Run____call_again_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame(); } if (!base.Run__Passage(__frame.Lend(__frame.Run____call_again_frame), __time, gates)) { return false; } }
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "again":
                    { global::Ariadne.IArcWriter scope = writer.Scope("Run.again/"); base.Run__LocalsToSave(__frame.Lend(__frame.Run____call_again_frame), depth + 1, scope); }
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionHelper
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame
        {
            public string Prepare__count;

            public global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame Prepare____call_prepared_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(lister);
                lister.Local<string>("Prepare.count");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Prepare.prepared/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                    }
                }
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionHelper()
        {
        }

        protected CollisionHelper(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected CollisionHelper(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("Note");
            lister.Local<string>("Prepare.count");
            {
                global::Ariadne.IArcPartLister scope = lister.Scope("Prepare.prepared/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                if (scope != null)
                {
                    global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                }
            }
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 84 "RunCollisionScripts.cs"
                      writer.Field<string>("Note", this.Note);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Prepare.count":
#line 88 "RunCollisionScripts.cs"
                   writer.Local<string>("Prepare.count", this.Prepare__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<string>("Prepare.count", out string loaded)) { this.Prepare__count = loaded; } }
                {
                    if (reader.TryScope("Prepare.prepared/", out global::Ariadne.IArcReader scope))
                    {
                        this.Prepare____call_prepared_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame();
                        this.Prepare____call_prepared_frame.LoadLocals(scope);
                    }
                }

            }

            public override void AttachWaits(global::Ariadne.WakeSlot slot)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.AttachWaits(slot);
                if (this.Prepare____call_prepared_frame != null) { this.Prepare____call_prepared_frame.AttachWaits(slot); }
            }

            public override void EndWaits()
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.EndWaits();
                if (this.Prepare____call_prepared_frame != null) { this.Prepare____call_prepared_frame.EndWaits(); }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            switch (__frame.ResumeKey)
            {
                case "Prepare": goto Prepare;
            }
#line hidden
            Prepare:
#line 97 "RunCollisionScripts.cs"
            using (__frame.Enter("Prepare")) { if (!Prepare__Passage(__frame, __time, gates)) { return false; } }
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "Prepare":
                    Prepare__LocalsToSave(__frame, depth + 1, writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Prepare__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref string count = ref __frame.Prepare__count;
            switch (__frame.ResumeKey)
            {
                case "prepared": goto prepared;
            }
#line 88 "RunCollisionScripts.cs"
            count = "p";
#line hidden
            prepared:
#line 91 "RunCollisionScripts.cs"
            using (__frame.Enter("prepared")) { if (__frame.Prepare____call_prepared_frame == null) { __frame.Prepare____call_prepared_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame(); } if (!base.Run__Passage(__frame.Lend(__frame.Prepare____call_prepared_frame), __time, gates)) { return false; } }
#line 92 "RunCollisionScripts.cs"
            Note = "prepared " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Prepare__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "prepared":
                    __frame.SaveLocal("Prepare.count", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Prepare.prepared/"); base.Run__LocalsToSave(__frame.Lend(__frame.Prepare____call_prepared_frame), depth + 1, scope); }
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionWaitBase
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Frame
        {
            public int Run__rounds;

            public global::Amphora.Duration Run____wait1;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<global::Amphora.Duration>("Run.__wait1");
                lister.Local<int>("Run.rounds");
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        protected CollisionWaitBase()
        {
        }

        protected CollisionWaitBase(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("WaitNote", out string loaded)) { this.WaitNote = loaded; } }
        }

        protected CollisionWaitBase(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("WaitNote");
            lister.Local<global::Amphora.Duration>("Run.__wait1");
            lister.Local<int>("Run.rounds");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 106 "RunCollisionScripts.cs"
                      writer.Field<string>("WaitNote", this.WaitNote);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.__wait1":
#line 113 "RunCollisionScripts.cs"
            writer.Local<global::Amphora.Duration>("Run.__wait1", this.Run____wait1);
#line hidden
                        return;
                    case "Run.rounds":
#line 110 "RunCollisionScripts.cs"
                writer.Local<int>("Run.rounds", this.Run__rounds);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<global::Amphora.Duration>("Run.__wait1", out global::Amphora.Duration loaded)) { this.Run____wait1 = loaded; } }
                { if (reader.TryLocal<int>("Run.rounds", out int loaded)) { this.Run__rounds = loaded; } }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref int rounds = ref __frame.Run__rounds;
            switch (__frame.ResumeKey)
            {
                case "rest": goto rest__resume;
            }
#line 110 "RunCollisionScripts.cs"
            rounds = 3;
#line hidden
            rest:
#line 113 "RunCollisionScripts.cs"
                 __frame.Run____wait1 = __time.DeadlineAfter(System.TimeSpan.FromSeconds(1));
#line hidden
            rest__resume:
#line 113 "RunCollisionScripts.cs"
            if (__time.GameTime < __frame.Run____wait1) { __frame.Sleep(__frame.Run____wait1); __frame.Mark("rest"); return false; }
#line 114 "RunCollisionScripts.cs"
            WaitNote = "rested " + rounds;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "rest":
                    __frame.SaveLocal("Run.rounds", writer);
                    __frame.SaveLocal("Run.__wait1", writer);
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionWaitDerived
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame
        {
            public string Run__rounds;

            public global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame Run____call_Run_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame.ListParts(lister);
                lister.Local<string>("Run.rounds");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame.ListParts(scope);
                    }
                }
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionWaitDerived()
        {
        }

        protected CollisionWaitDerived(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected CollisionWaitDerived(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("Note");
            lister.Local<string>("Run.rounds");
            {
                global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame));
                if (scope != null)
                {
                    global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame.ListParts(scope);
                }
            }
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 123 "RunCollisionScripts.cs"
                      writer.Field<string>("Note", this.Note);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.rounds":
#line 127 "RunCollisionScripts.cs"
                   writer.Local<string>("Run.rounds", this.Run__rounds);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<string>("Run.rounds", out string loaded)) { this.Run__rounds = loaded; } }
                {
                    if (reader.TryScope("Run.Run/", out global::Ariadne.IArcReader scope))
                    {
                        this.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame();
                        this.Run____call_Run_frame.LoadLocals(scope);
                    }
                }

            }

            public override void AttachWaits(global::Ariadne.WakeSlot slot)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.AttachWaits(slot);
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.AttachWaits(slot); }
            }

            public override void EndWaits()
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.EndWaits();
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.EndWaits(); }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref string rounds = ref __frame.Run__rounds;
            switch (__frame.ResumeKey)
            {
                case "Run": goto Run;
            }
#line 127 "RunCollisionScripts.cs"
            rounds = "x";
#line hidden
            Run:
#line 129 "RunCollisionScripts.cs"
            using (__frame.Enter("Run")) { if (__frame.Run____call_Run_frame == null) { __frame.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionWaitBase.__Frame(); } if (!base.Run__Passage(__frame.Lend(__frame.Run____call_Run_frame), __time, gates)) { return false; } }
#line 130 "RunCollisionScripts.cs"
            Note = "derived " + rounds;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "Run":
                    __frame.SaveLocal("Run.rounds", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Run.Run/"); base.Run__LocalsToSave(__frame.Lend(__frame.Run____call_Run_frame), depth + 1, scope); }
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionMiddle
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame
        {
            public double Run__count;

            public global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame Run____call_Run_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(lister);
                lister.Local<double>("Run.count");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                    }
                }
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionMiddle()
        {
        }

        protected CollisionMiddle(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("MiddleNote", out string loaded)) { this.MiddleNote = loaded; } }
        }

        protected CollisionMiddle(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("MiddleNote");
            lister.Local<double>("Run.count");
            {
                global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame));
                if (scope != null)
                {
                    global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(scope);
                }
            }
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 139 "RunCollisionScripts.cs"
                      writer.Field<string>("MiddleNote", this.MiddleNote);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 143 "RunCollisionScripts.cs"
                   writer.Local<double>("Run.count", this.Run__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<double>("Run.count", out double loaded)) { this.Run__count = loaded; } }
                {
                    if (reader.TryScope("Run.Run/", out global::Ariadne.IArcReader scope))
                    {
                        this.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame();
                        this.Run____call_Run_frame.LoadLocals(scope);
                    }
                }

            }

            public override void AttachWaits(global::Ariadne.WakeSlot slot)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.AttachWaits(slot);
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.AttachWaits(slot); }
            }

            public override void EndWaits()
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.EndWaits();
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.EndWaits(); }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref double count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "middlewait": goto middlewait;
                case "Run": goto Run;
            }
#line 143 "RunCollisionScripts.cs"
            count = 2.5;
#line hidden
            middlewait:
#line 146 "RunCollisionScripts.cs"
            while (!gates.Open.Contains("middle"))
#line hidden
            {
#line 148 "RunCollisionScripts.cs"
                __frame.Mark("middlewait"); return false;
#line hidden
            }
#line hidden
            Run:
#line 151 "RunCollisionScripts.cs"
            using (__frame.Enter("Run")) { if (__frame.Run____call_Run_frame == null) { __frame.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame(); } if (!base.Run__Passage(__frame.Lend(__frame.Run____call_Run_frame), __time, gates)) { return false; } }
#line 152 "RunCollisionScripts.cs"
            MiddleNote = "middle " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "middlewait":
                    __frame.SaveLocal("Run.count", writer);
                    break;
                case "Run":
                    __frame.SaveLocal("Run.count", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Run.Run/"); base.Run__LocalsToSave(__frame.Lend(__frame.Run____call_Run_frame), depth + 1, scope); }
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionLeaf
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame
        {
            public string Run__count;

            public global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame Run____call_Run_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame.ListParts(lister);
                lister.Local<string>("Run.count");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame.ListParts(scope);
                    }
                }
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionLeaf()
        {
        }

        protected CollisionLeaf(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected CollisionLeaf(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("Note");
            lister.Local<string>("Run.count");
            {
                global::Ariadne.IArcPartLister scope = lister.Scope("Run.Run/", typeof(global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame));
                if (scope != null)
                {
                    global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame.ListParts(scope);
                }
            }
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 161 "RunCollisionScripts.cs"
                      writer.Field<string>("Note", this.Note);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 165 "RunCollisionScripts.cs"
                   writer.Local<string>("Run.count", this.Run__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<string>("Run.count", out string loaded)) { this.Run__count = loaded; } }
                {
                    if (reader.TryScope("Run.Run/", out global::Ariadne.IArcReader scope))
                    {
                        this.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame();
                        this.Run____call_Run_frame.LoadLocals(scope);
                    }
                }

            }

            public override void AttachWaits(global::Ariadne.WakeSlot slot)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.AttachWaits(slot);
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.AttachWaits(slot); }
            }

            public override void EndWaits()
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.EndWaits();
                if (this.Run____call_Run_frame != null) { this.Run____call_Run_frame.EndWaits(); }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref string count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "leafwait": goto leafwait;
                case "Run": goto Run;
            }
#line 165 "RunCollisionScripts.cs"
            count = "leaf";
#line hidden
            leafwait:
#line 168 "RunCollisionScripts.cs"
            while (!gates.Open.Contains("start"))
#line hidden
            {
#line 170 "RunCollisionScripts.cs"
                __frame.Mark("leafwait"); return false;
#line hidden
            }
#line hidden
            Run:
#line 173 "RunCollisionScripts.cs"
            using (__frame.Enter("Run")) { if (__frame.Run____call_Run_frame == null) { __frame.Run____call_Run_frame = new global::Ariadne.Vellum.UnitTests.CollisionMiddle.__Frame(); } if (!base.Run__Passage(__frame.Lend(__frame.Run____call_Run_frame), __time, gates)) { return false; } }
#line 174 "RunCollisionScripts.cs"
            Note = "leaf " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "leafwait":
                    __frame.SaveLocal("Run.count", writer);
                    break;
                case "Run":
                    __frame.SaveLocal("Run.count", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Run.Run/"); base.Run__LocalsToSave(__frame.Lend(__frame.Run____call_Run_frame), depth + 1, scope); }
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests
{
    partial class CollisionSameType
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame
        {
            public int Run__count;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                global::Ariadne.Vellum.UnitTests.CollisionBase.__Frame.ListParts(lister);
                lister.Local<int>("Run.count");
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected override global::Ariadne.Frame __CreateFrame()
        {
            return new __Frame();
        }

        [global::System.CodeDom.Compiler.GeneratedCode("Ariadne.Generator", "1.0")]
        protected override bool __Resume(global::Ariadne.UnitTests.ArcTests.Gates context, global::Ariadne.TickTime __time)
        {
            return Run__Passage((__Frame)__CurrentFrame, __time, context);
        }

        protected override void __SaveLocals(global::Ariadne.IArcWriter writer)
        {
            Run__LocalsToSave((__Frame)__CurrentFrame, 0, writer);
        }

        public CollisionSameType()
        {
        }

        protected CollisionSameType(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected CollisionSameType(global::Ariadne.IArcReader reader)
            : this(reader, default(global::Ariadne.AutoLoadEveryField))
        {
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        private static void __ListParts(global::Ariadne.IArcPartLister lister)
        {
            lister.Field<string>("Note");
            lister.Local<int>("Run.count");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 183 "RunCollisionScripts.cs"
                      writer.Field<string>("Note", this.Note);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 187 "RunCollisionScripts.cs"
                writer.Local<int>("Run.count", this.Run__count);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class __Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<int>("Run.count", out int loaded)) { this.Run__count = loaded; } }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Gates gates)
        {
#line hidden
            ref int count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "derivedwait": goto derivedwait;
            }
#line 187 "RunCollisionScripts.cs"
            count = 5;
#line hidden
            derivedwait:
#line 190 "RunCollisionScripts.cs"
            while (!gates.Open.Contains("go"))
#line hidden
            {
#line 192 "RunCollisionScripts.cs"
                __frame.Mark("derivedwait"); return false;
#line hidden
            }
#line 195 "RunCollisionScripts.cs"
            Note = "derived " + count;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected void Run__LocalsToSave(__Frame __frame, int depth, global::Ariadne.IArcWriter writer)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "derivedwait":
                    __frame.SaveLocal("Run.count", writer);
                    break;
            }
        }

    }
}