// <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
using System.Collections.Generic;


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

            public int Hold__seen;

            public int Count__seen;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<int>("Count.seen");
                lister.Local<int>("Hold.bonus");
                lister.Local<int>("Hold.seen");
            }
        }

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

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class Weigh__Frame<ItemType> : global::Ariadne.Frame
        {
            public ItemType Weigh__weighed;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<ItemType>("Weigh.weighed");
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class Descend__Frame : global::Ariadne.Frame
        {
            public int Descend__depth;

            public int Descend__level;

            public global::Ariadne.Vellum.UnitTests.Library.VaultHost.Descend__Frame Descend____call_deeper_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<int>("Descend.depth");
                lister.Local<int>("Descend.level");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Descend.deeper/", typeof(global::Ariadne.Vellum.UnitTests.Library.VaultHost.Descend__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.Library.VaultHost.Descend__Frame.ListParts(scope);
                    }
                }
            }
        }

        protected VaultHost()
        {
        }

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

        protected VaultHost(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>("Count.seen");
            lister.Local<int>("Hold.bonus");
            lister.Local<int>("Hold.seen");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 15 "Vault.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 "Count.seen":
#line 33 "Vault.cs"
                writer.Local<int>("Count.seen", this.Count__seen);
#line hidden
                        return;
                    case "Hold.bonus":
#line 17 "Vault.cs"
                                             writer.Local<int>("Hold.bonus", this.Hold__bonus);
#line hidden
                        return;
                    case "Hold.seen":
#line 19 "Vault.cs"
                writer.Local<int>("Hold.seen", this.Hold__seen);
#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>("Count.seen", out int loaded)) { this.Count__seen = loaded; } }
                { if (reader.TryLocal<int>("Hold.bonus", out int loaded)) { this.Hold__bonus = loaded; } }
                { if (reader.TryLocal<int>("Hold.seen", out int loaded)) { this.Hold__seen = loaded; } }
            }

        }

#pragma warning restore
        public partial class Weigh__Frame<ItemType>
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Weigh.weighed":
#line 47 "Vault.cs"
                     writer.Local<ItemType>("Weigh.weighed", this.Weigh__weighed);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class Weigh__Frame<ItemType>
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<ItemType>("Weigh.weighed", out ItemType loaded)) { this.Weigh__weighed = loaded; } }
            }

        }

#pragma warning restore
        public partial class Descend__Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Descend.depth":
#line 58 "Vault.cs"
                                                writer.Local<int>("Descend.depth", this.Descend__depth);
#line hidden
                        return;
                    case "Descend.level":
#line 60 "Vault.cs"
                writer.Local<int>("Descend.level", this.Descend__level);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class Descend__Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<int>("Descend.depth", out int loaded)) { this.Descend__depth = loaded; } }
                { if (reader.TryLocal<int>("Descend.level", out int loaded)) { this.Descend__level = loaded; } }
                {
                    if (reader.TryScope("Descend.deeper/", out global::Ariadne.IArcReader scope))
                    {
                        this.Descend____call_deeper_frame = new global::Ariadne.Vellum.UnitTests.Library.VaultHost.Descend__Frame();
                        this.Descend____call_deeper_frame.LoadLocals(scope);
                    }
                }

            }

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

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

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Hold__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault, int bonus__argument)
        {
#line hidden
            ref int bonus = ref __frame.Hold__bonus;
            if (__frame.ResumeKey == null)
            {
                bonus = bonus__argument;
            }

            ref int seen = ref __frame.Hold__seen;
            switch (__frame.ResumeKey)
            {
                case "hold": goto hold;
            }
#line 19 "Vault.cs"
            seen = 0;
#line hidden
            hold:
#line 22 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 24 "Vault.cs"
                seen++;
#line 25 "Vault.cs"
                __frame.Mark("hold"); return false;
#line hidden
            }
#line 28 "Vault.cs"
            Note = "held " + (seen + bonus);
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "hold":
                    __frame.SaveLocal("Hold.bonus", writer);
                    __frame.SaveLocal("Hold.seen", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Count__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault, out int __result)
        {
#line hidden
            __result = default(int);
            ref int seen = ref __frame.Count__seen;
            switch (__frame.ResumeKey)
            {
                case "count": goto count;
            }
#line 33 "Vault.cs"
            seen = 0;
#line hidden
            count:
#line 36 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 38 "Vault.cs"
                seen++;
#line 39 "Vault.cs"
                __frame.Mark("count"); return false;
#line hidden
            }
#line 42 "Vault.cs"
            { __result = seen; __frame.Exit(); return true; }
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

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

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Weigh__Passage<ItemType>(Weigh__Frame<ItemType> __frame, __Frame __arcFrame, global::Ariadne.TickTime __time, Vault vault, ItemType item)
        {
#line hidden
            ref ItemType weighed = ref __frame.Weigh__weighed;
            switch (__frame.ResumeKey)
            {
                case "weigh": goto weigh;
            }
#line 47 "Vault.cs"
            weighed = item;
#line hidden
            weigh:
#line 50 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 52 "Vault.cs"
                __frame.Mark("weigh"); return false;
#line hidden
            }
#line 55 "Vault.cs"
            Note = "weighed " + weighed;
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "weigh":
                    __frame.SaveLocal("Weigh.weighed", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Descend__Passage(Descend__Frame __frame, __Frame __arcFrame, global::Ariadne.TickTime __time, Vault vault, int depth__argument)
        {
#line hidden
            ref int depth = ref __frame.Descend__depth;
            if (__frame.ResumeKey == null)
            {
                depth = depth__argument;
            }

            ref int level = ref __frame.Descend__level;
            switch (__frame.ResumeKey)
            {
                case "deeper": goto deeper;
                case "landed": goto landed;
            }
#line 60 "Vault.cs"
            level = depth;
#line hidden
        {
#line 62 "Vault.cs"
            if (!(depth > 0)) goto __end1;
#line hidden
        }
#line hidden
                deeper:
#line hidden
            {
#line 65 "Vault.cs"
                using (__frame.Enter("deeper")) { global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack(); if (__frame.Descend____call_deeper_frame == null) { __frame.Descend____call_deeper_frame = new global::Ariadne.Vellum.UnitTests.Library.VaultHost.Descend__Frame(); } if (!Descend__Passage(__frame.Lend(__frame.Descend____call_deeper_frame), __arcFrame, __time, vault, __frame.ResumeKey == null ? (depth - 1) : default(int))) { return false; } }
#line hidden
            }
#line hidden
            __end1:
#line hidden
            landed:
#line 69 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 71 "Vault.cs"
                __frame.Mark("landed"); return false;
#line hidden
            }
#line 74 "Vault.cs"
            Note += "level" + level + ";";
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "deeper":
                    __frame.SaveLocal("Descend.depth", writer);
                    __frame.SaveLocal("Descend.level", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Descend.deeper/"); Descend__LocalsToSave(__frame.Lend(__frame.Descend____call_deeper_frame), __arcFrame, depth + 1, scope, arcWriter); }
                    break;
                case "landed":
                    __frame.SaveLocal("Descend.level", writer);
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests.Library
{
    partial class VaultTagged<TagType>
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Frame
        {
            public TagType Settle__kept;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<TagType>("Settle.kept");
            }
        }

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

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class Hold__Frame<ItemType> : global::Ariadne.Frame
        {
            public TagType Hold__kept;

            public ItemType Hold__carried;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<ItemType>("Hold.carried");
                lister.Local<TagType>("Hold.kept");
            }
        }

        protected VaultTagged()
        {
        }

        protected VaultTagged(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<TagType>("Last", out TagType loaded)) { this.Last = loaded; } else if (!reader.HasField("Last")) { throw new global::System.IO.InvalidDataException("VaultTagged's save has no field 'Last', which has no initializer to fall back on.  Give it one."); } }
            { if (reader.TryField<string>("Log", out string loaded)) { this.Log = loaded; } }
        }

        protected VaultTagged(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<TagType>("Last");
            lister.Field<string>("Log");
            lister.Local<TagType>("Settle.kept");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 83 "Vault.cs"
                       writer.Field<TagType>("Last", this.Last);
#line 85 "Vault.cs"
                      writer.Field<string>("Log", this.Log);
#line default
        }

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Settle.kept":
#line 89 "Vault.cs"
                    writer.Local<TagType>("Settle.kept", this.Settle__kept);
#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<TagType>("Settle.kept", out TagType loaded)) { this.Settle__kept = loaded; } }
            }

        }

#pragma warning restore
        public partial class Hold__Frame<ItemType>
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Hold.carried":
#line 103 "Vault.cs"
                     writer.Local<ItemType>("Hold.carried", this.Hold__carried);
#line hidden
                        return;
                    case "Hold.kept":
#line 102 "Vault.cs"
                    writer.Local<TagType>("Hold.kept", this.Hold__kept);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class Hold__Frame<ItemType>
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<ItemType>("Hold.carried", out ItemType loaded)) { this.Hold__carried = loaded; } }
                { if (reader.TryLocal<TagType>("Hold.kept", out TagType loaded)) { this.Hold__kept = loaded; } }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Settle__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault, TagType tag)
        {
#line hidden
            ref TagType kept = ref __frame.Settle__kept;
            switch (__frame.ResumeKey)
            {
                case "settle": goto settle;
            }
#line 89 "Vault.cs"
            kept = tag;
#line hidden
            settle:
#line 92 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 94 "Vault.cs"
                __frame.Mark("settle"); return false;
#line hidden
            }
#line 97 "Vault.cs"
            Last = kept;
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "settle":
                    __frame.SaveLocal("Settle.kept", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Hold__Passage<ItemType>(Hold__Frame<ItemType> __frame, __Frame __arcFrame, global::Ariadne.TickTime __time, Vault vault, TagType tag, ItemType item)
        {
#line hidden
            ref TagType kept = ref __frame.Hold__kept;
            ref ItemType carried = ref __frame.Hold__carried;
            switch (__frame.ResumeKey)
            {
                case "hold": goto hold;
            }
#line 102 "Vault.cs"
            kept = tag;
#line 103 "Vault.cs"
            carried = item;
#line hidden
            hold:
#line 106 "Vault.cs"
            while (!vault.Open.Contains("held"))
#line hidden
            {
#line 108 "Vault.cs"
                __frame.Mark("hold"); return false;
#line hidden
            }
#line 111 "Vault.cs"
            Last = kept;
#line 112 "Vault.cs"
            Log += carried + ";";
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "hold":
                    __frame.SaveLocal("Hold.kept", writer);
                    __frame.SaveLocal("Hold.carried", writer);
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests.Library
{
    partial class VaultShelf<ItemType>
    {
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class __Frame : global::Ariadne.Frame
        {
            public ItemType Stock__stocked;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<ItemType>("Stock.stocked");
            }
        }

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

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class Label__Frame<TagType> : global::Ariadne.Frame
        {
            public ItemType Label__labeled;

            public TagType Label__kept;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<TagType>("Label.kept");
                lister.Local<ItemType>("Label.labeled");
            }
        }

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

        public VaultShelf()
        {
        }

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

        protected VaultShelf(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<ItemType>("Stock.stocked");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 121 "Vault.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 "Stock.stocked":
#line 125 "Vault.cs"
                     writer.Local<ItemType>("Stock.stocked", this.Stock__stocked);
#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<ItemType>("Stock.stocked", out ItemType loaded)) { this.Stock__stocked = loaded; } }
            }

        }

#pragma warning restore
        public partial class Label__Frame<TagType>
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Label.kept":
#line 139 "Vault.cs"
                    writer.Local<TagType>("Label.kept", this.Label__kept);
#line hidden
                        return;
                    case "Label.labeled":
#line 138 "Vault.cs"
                     writer.Local<ItemType>("Label.labeled", this.Label__labeled);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class Label__Frame<TagType>
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<TagType>("Label.kept", out TagType loaded)) { this.Label__kept = loaded; } }
                { if (reader.TryLocal<ItemType>("Label.labeled", out ItemType loaded)) { this.Label__labeled = loaded; } }
            }

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault)
        {
#line hidden
            switch (__frame.ResumeKey)
            {
            }
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public bool Stock__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault, ItemType item)
        {
#line hidden
            ref ItemType stocked = ref __frame.Stock__stocked;
            switch (__frame.ResumeKey)
            {
                case "stock": goto stock;
            }
#line 125 "Vault.cs"
            stocked = item;
#line hidden
            stock:
#line 128 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 130 "Vault.cs"
                __frame.Mark("stock"); return false;
#line hidden
            }
#line 133 "Vault.cs"
            Note = "stocked " + stocked;
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "stock":
                    __frame.SaveLocal("Stock.stocked", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public bool Label__Passage<TagType>(Label__Frame<TagType> __frame, __Frame __arcFrame, global::Ariadne.TickTime __time, Vault vault, ItemType item, TagType tag)
        {
#line hidden
            ref ItemType labeled = ref __frame.Label__labeled;
            ref TagType kept = ref __frame.Label__kept;
            switch (__frame.ResumeKey)
            {
                case "label": goto label;
            }
#line 138 "Vault.cs"
            labeled = item;
#line 139 "Vault.cs"
            kept = tag;
#line hidden
            label:
#line 142 "Vault.cs"
            while (!vault.Open.Contains("labeled"))
#line hidden
            {
#line 144 "Vault.cs"
                __frame.Mark("label"); return false;
#line hidden
            }
#line 147 "Vault.cs"
            Note = "labeled " + labeled + kept;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public void Label__LocalsToSave<TagType>(Label__Frame<TagType> __frame, __Frame __arcFrame, int depth, global::Ariadne.IArcWriter writer, global::Ariadne.IArcWriter arcWriter)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "label":
                    __frame.SaveLocal("Label.labeled", writer);
                    __frame.SaveLocal("Label.kept", writer);
                    break;
            }
        }

    }
}


namespace Ariadne.Vellum.UnitTests.Library
{
    partial class VaultTemplate
    {
        [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.Vellum.UnitTests.Library.Vault 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 VaultTemplate()
        {
        }

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

        protected VaultTemplate(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>("TemplateNote");
            lister.Local<int>("Run.count");
        }

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

        public partial class __Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Run.count":
#line 164 "Vault.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, Vault vault)
        {
#line hidden
            ref int count = ref __frame.Run__count;
            switch (__frame.ResumeKey)
            {
                case "template": goto template;
            }
#line 164 "Vault.cs"
            count = 1;
#line hidden
            template:
#line 167 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 169 "Vault.cs"
                __frame.Mark("template"); return false;
#line hidden
            }
#line 172 "Vault.cs"
            TemplateNote = "template " + 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 "template":
                    __frame.SaveLocal("Run.count", writer);
                    break;
            }
        }

    }
}


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

            public int Update__waited;

            public int Measure__waited;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<int>("Measure.waited");
                lister.Local<int>("Update.bonus");
                lister.Local<int>("Update.waited");
            }
        }

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

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class Ponder__Frame<ItemType> : global::Ariadne.Frame
        {
            public ItemType Ponder__held;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<ItemType>("Ponder.held");
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public partial class Dig__Frame : global::Ariadne.Frame
        {
            public int Dig__depth;

            public int Dig__level;

            public global::Ariadne.Vellum.UnitTests.Library.VaultPlant.Dig__Frame Dig____call_deeper_frame;

            public static void ListParts(global::Ariadne.IArcPartLister lister)
            {
                lister.Local<int>("Dig.depth");
                lister.Local<int>("Dig.level");
                {
                    global::Ariadne.IArcPartLister scope = lister.Scope("Dig.deeper/", typeof(global::Ariadne.Vellum.UnitTests.Library.VaultPlant.Dig__Frame));
                    if (scope != null)
                    {
                        global::Ariadne.Vellum.UnitTests.Library.VaultPlant.Dig__Frame.ListParts(scope);
                    }
                }
            }
        }

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

        public VaultPlant()
        {
        }

        protected VaultPlant(global::Ariadne.IArcReader reader, global::Ariadne.AutoLoadEveryField load) : base(reader)
        {
            { if (reader.TryField<int>("Updates", out int loaded)) { this.Updates = loaded; } else if (!reader.HasField("Updates")) { throw new global::System.IO.InvalidDataException("VaultPlant's save has no field 'Updates', which has no initializer to fall back on.  Give it one."); } }
            { if (reader.TryField<string>("Note", out string loaded)) { this.Note = loaded; } }
        }

        protected VaultPlant(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<int>("Updates");
            lister.Field<string>("Note");
            lister.Local<int>("Measure.waited");
            lister.Local<int>("Update.bonus");
            lister.Local<int>("Update.waited");
        }

#pragma warning restore
        protected override void __SaveFields(global::Ariadne.IArcWriter writer)
        {
            base.__SaveFields(writer);
#line 181 "Vault.cs"
                   writer.Field<int>("Updates", this.Updates);
#line 183 "Vault.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 "Measure.waited":
#line 202 "Vault.cs"
                writer.Local<int>("Measure.waited", this.Measure__waited);
#line hidden
                        return;
                    case "Update.bonus":
#line 185 "Vault.cs"
                                            writer.Local<int>("Update.bonus", this.Update__bonus);
#line hidden
                        return;
                    case "Update.waited":
#line 187 "Vault.cs"
                writer.Local<int>("Update.waited", this.Update__waited);
#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>("Measure.waited", out int loaded)) { this.Measure__waited = loaded; } }
                { if (reader.TryLocal<int>("Update.bonus", out int loaded)) { this.Update__bonus = loaded; } }
                { if (reader.TryLocal<int>("Update.waited", out int loaded)) { this.Update__waited = loaded; } }
            }

        }

#pragma warning restore
        public partial class Ponder__Frame<ItemType>
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Ponder.held":
#line 216 "Vault.cs"
                     writer.Local<ItemType>("Ponder.held", this.Ponder__held);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class Ponder__Frame<ItemType>
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                base.LoadLocals(reader);
                { if (reader.TryLocal<ItemType>("Ponder.held", out ItemType loaded)) { this.Ponder__held = loaded; } }
            }

        }

#pragma warning restore
        public partial class Dig__Frame
        {
            public override void SaveLocal(string key, global::Ariadne.IArcWriter writer)
            {
                switch (key)
                {
                    case "Dig.depth":
#line 227 "Vault.cs"
                                         writer.Local<int>("Dig.depth", this.Dig__depth);
#line hidden
                        return;
                    case "Dig.level":
#line 229 "Vault.cs"
                writer.Local<int>("Dig.level", this.Dig__level);
#line hidden
                        return;
                }
#line default

                base.SaveLocal(key, writer);
            }

        }

#pragma warning disable
        public partial class Dig__Frame
        {
            public override void LoadLocals(global::Ariadne.IArcReader reader)
            {
                global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack();
                base.LoadLocals(reader);
                { if (reader.TryLocal<int>("Dig.depth", out int loaded)) { this.Dig__depth = loaded; } }
                { if (reader.TryLocal<int>("Dig.level", out int loaded)) { this.Dig__level = loaded; } }
                {
                    if (reader.TryScope("Dig.deeper/", out global::Ariadne.IArcReader scope))
                    {
                        this.Dig____call_deeper_frame = new global::Ariadne.Vellum.UnitTests.Library.VaultPlant.Dig__Frame();
                        this.Dig____call_deeper_frame.LoadLocals(scope);
                    }
                }

            }

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

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

        }

#pragma warning disable
        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        protected bool Run__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault)
        {
#line hidden
            switch (__frame.ResumeKey)
            {
            }
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public bool Update__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault, int bonus__argument)
        {
#line hidden
            ref int bonus = ref __frame.Update__bonus;
            if (__frame.ResumeKey == null)
            {
                bonus = bonus__argument;
            }

            ref int waited = ref __frame.Update__waited;
            switch (__frame.ResumeKey)
            {
                case "wait": goto wait;
            }
#line 187 "Vault.cs"
            waited = 0;
#line hidden
            wait:
#line 190 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 192 "Vault.cs"
                waited++;
#line 193 "Vault.cs"
                __frame.Mark("wait"); return false;
#line hidden
            }
#line 196 "Vault.cs"
            Updates += waited + bonus;
#line 197 "Vault.cs"
            Note = "updated after " + waited;
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "wait":
                    __frame.SaveLocal("Update.bonus", writer);
                    __frame.SaveLocal("Update.waited", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public bool Measure__Passage(__Frame __frame, global::Ariadne.TickTime __time, Vault vault, out int __result)
        {
#line hidden
            __result = default(int);
            ref int waited = ref __frame.Measure__waited;
            switch (__frame.ResumeKey)
            {
                case "measure": goto measure;
            }
#line 202 "Vault.cs"
            waited = 0;
#line hidden
            measure:
#line 205 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 207 "Vault.cs"
                waited++;
#line 208 "Vault.cs"
                __frame.Mark("measure"); return false;
#line hidden
            }
#line 211 "Vault.cs"
            { __result = waited; __frame.Exit(); return true; }
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "measure":
                    __frame.SaveLocal("Measure.waited", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public bool Ponder__Passage<ItemType>(Ponder__Frame<ItemType> __frame, __Frame __arcFrame, global::Ariadne.TickTime __time, Vault vault, ItemType item)
        {
#line hidden
            ref ItemType held = ref __frame.Ponder__held;
            switch (__frame.ResumeKey)
            {
                case "ponder": goto ponder;
            }
#line 216 "Vault.cs"
            held = item;
#line hidden
            ponder:
#line 219 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 221 "Vault.cs"
                __frame.Mark("ponder"); return false;
#line hidden
            }
#line 224 "Vault.cs"
            Note = "pondered " + held;
#line hidden
            __frame.Exit(); return true;
#line default
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public void Ponder__LocalsToSave<ItemType>(Ponder__Frame<ItemType> __frame, __Frame __arcFrame, int depth, global::Ariadne.IArcWriter writer, global::Ariadne.IArcWriter arcWriter)
        {
            if (depth >= __frame.Cursor.Count)
            {
                return;
            }

            switch (__frame.Cursor[depth])
            {
                case "ponder":
                    __frame.SaveLocal("Ponder.held", writer);
                    break;
            }
        }

        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
        public bool Dig__Passage(Dig__Frame __frame, __Frame __arcFrame, global::Ariadne.TickTime __time, Vault vault, int depth__argument)
        {
#line hidden
            ref int depth = ref __frame.Dig__depth;
            if (__frame.ResumeKey == null)
            {
                depth = depth__argument;
            }

            ref int level = ref __frame.Dig__level;
            switch (__frame.ResumeKey)
            {
                case "deeper": goto deeper;
                case "dug": goto dug;
            }
#line 229 "Vault.cs"
            level = depth;
#line hidden
        {
#line 231 "Vault.cs"
            if (!(depth > 0)) goto __end1;
#line hidden
        }
#line hidden
                deeper:
#line hidden
            {
#line 234 "Vault.cs"
                using (__frame.Enter("deeper")) { global::System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack(); if (__frame.Dig____call_deeper_frame == null) { __frame.Dig____call_deeper_frame = new global::Ariadne.Vellum.UnitTests.Library.VaultPlant.Dig__Frame(); } if (!Dig__Passage(__frame.Lend(__frame.Dig____call_deeper_frame), __arcFrame, __time, vault, __frame.ResumeKey == null ? (depth - 1) : default(int))) { return false; } }
#line hidden
            }
#line hidden
            __end1:
#line hidden
            dug:
#line 238 "Vault.cs"
            while (!vault.Open.Contains("go"))
#line hidden
            {
#line 240 "Vault.cs"
                __frame.Mark("dug"); return false;
#line hidden
            }
#line 243 "Vault.cs"
            Updates += level;
#line hidden
            __frame.Exit(); return true;
#line default
        }

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

            switch (__frame.Cursor[depth])
            {
                case "deeper":
                    __frame.SaveLocal("Dig.depth", writer);
                    __frame.SaveLocal("Dig.level", writer);
                    { global::Ariadne.IArcWriter scope = writer.Scope("Dig.deeper/"); Dig__LocalsToSave(__frame.Lend(__frame.Dig____call_deeper_frame), __arcFrame, depth + 1, scope, arcWriter); }
                    break;
                case "dug":
                    __frame.SaveLocal("Dig.level", writer);
                    break;
            }
        }

    }
}