text:
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Reflection.Metadata;

namespace Cometary
{
    partial class IL
    {
        #region No parameters
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Add"/>:</para>
        ///   <para>"Add two values, returning a new value."</para>
        /// </summary>
        public static void Add() => Emit((ILOpCode)OpCodes.Add.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Add_Ovf"/>:</para>
        ///   <para>"Add signed integer values with overflow check."</para>
        /// </summary>
        public static void Add_Ovf() => Emit((ILOpCode)OpCodes.Add_Ovf.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Add_Ovf_Un"/>:</para>
        ///   <para>"Add unsigned integer values with overflow check."</para>
        /// </summary>
        public static void Add_Ovf_Un() => Emit((ILOpCode)OpCodes.Add_Ovf_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.And"/>:</para>
        ///   <para>"Bitwise AND of two integral values, returns an integral value."</para>
        /// </summary>
        public static void And() => Emit((ILOpCode)OpCodes.And.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Arglist"/>:</para>
        ///   <para>"Return argument list handle for the current method."</para>
        /// </summary>
        public static void Arglist() => Emit((ILOpCode)OpCodes.Arglist.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Break"/>:</para>
        ///   <para>"Inform a debugger that a breakpoint has been reached."</para>
        /// </summary>
        public static void Break() => Emit((ILOpCode)OpCodes.Break.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ceq"/>:</para>
        ///   <para>"Push 1 (of type int32) if value1 equals value2, else push 0."</para>
        /// </summary>
        public static void Ceq() => Emit((ILOpCode)OpCodes.Ceq.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Cgt"/>:</para>
        ///   <para>"Push 1 (of type int32) if value1 > value2, else push 0."</para>
        /// </summary>
        public static void Cgt() => Emit((ILOpCode)OpCodes.Cgt.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Cgt_Un"/>:</para>
        ///   <para>"Push 1 (of type int32) if value1 > value2, unsigned or unordered, else push 0."</para>
        /// </summary>
        public static void Cgt_Un() => Emit((ILOpCode)OpCodes.Cgt_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ckfinite"/>:</para>
        ///   <para>"Throw ArithmeticException if value is not a finite number."</para>
        /// </summary>
        public static void Ckfinite() => Emit((ILOpCode)OpCodes.Ckfinite.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Clt"/>:</para>
        ///   <para>"Push 1 (of type int32) if value1 < value2, else push 0."</para>
        /// </summary>
        public static void Clt() => Emit((ILOpCode)OpCodes.Clt.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Clt_Un"/>:</para>
        ///   <para>"Push 1 (of type int32) if value1 < value2, unsigned or unordered, else push 0."</para>
        /// </summary>
        public static void Clt_Un() => Emit((ILOpCode)OpCodes.Clt_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_I"/>:</para>
        ///   <para>"Convert to native int, pushing native int on stack."</para>
        /// </summary>
        public static void Conv_I() => Emit((ILOpCode)OpCodes.Conv_I.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_I1"/>:</para>
        ///   <para>"Convert to int8, pushing int32 on stack."</para>
        /// </summary>
        public static void Conv_I1() => Emit((ILOpCode)OpCodes.Conv_I1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_I2"/>:</para>
        ///   <para>"Convert to int16, pushing int32 on stack."</para>
        /// </summary>
        public static void Conv_I2() => Emit((ILOpCode)OpCodes.Conv_I2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_I4"/>:</para>
        ///   <para>"Convert to int32, pushing int32 on stack."</para>
        /// </summary>
        public static void Conv_I4() => Emit((ILOpCode)OpCodes.Conv_I4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_I8"/>:</para>
        ///   <para>"Convert to int64, pushing int64 on stack."</para>
        /// </summary>
        public static void Conv_I8() => Emit((ILOpCode)OpCodes.Conv_I8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I"/>:</para>
        ///   <para>"Convert to a native int (on the stack as native int) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I() => Emit((ILOpCode)OpCodes.Conv_Ovf_I.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I_Un"/>:</para>
        ///   <para>"Convert unsigned to a native int (on the stack as native int) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_I_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I1"/>:</para>
        ///   <para>"Convert to an int8 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I1() => Emit((ILOpCode)OpCodes.Conv_Ovf_I1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I1_Un"/>:</para>
        ///   <para>"Convert unsigned to an int8 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I1_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_I1_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I2"/>:</para>
        ///   <para>"Convert to an int16 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I2() => Emit((ILOpCode)OpCodes.Conv_Ovf_I2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I2_Un"/>:</para>
        ///   <para>"Convert unsigned to an int16 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I2_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_I2_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I4"/>:</para>
        ///   <para>"Convert to an int32 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I4() => Emit((ILOpCode)OpCodes.Conv_Ovf_I4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I4_Un"/>:</para>
        ///   <para>"Convert unsigned to an int32 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I4_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_I4_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I8"/>:</para>
        ///   <para>"Convert to an int64 (on the stack as int64) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I8() => Emit((ILOpCode)OpCodes.Conv_Ovf_I8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_I8_Un"/>:</para>
        ///   <para>"Convert unsigned to an int64 (on the stack as int64) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_I8_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_I8_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U"/>:</para>
        ///   <para>"Convert to a native unsigned int (on the stack as native int) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U() => Emit((ILOpCode)OpCodes.Conv_Ovf_U.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U_Un"/>:</para>
        ///   <para>"Convert unsigned to a native unsigned int (on the stack as native int) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_U_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U1"/>:</para>
        ///   <para>"Convert to an unsigned int8 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U1() => Emit((ILOpCode)OpCodes.Conv_Ovf_U1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U1_Un"/>:</para>
        ///   <para>"Convert unsigned to an unsigned int8 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U1_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_U1_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U2"/>:</para>
        ///   <para>"Convert to an unsigned int16 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U2() => Emit((ILOpCode)OpCodes.Conv_Ovf_U2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U2_Un"/>:</para>
        ///   <para>"Convert unsigned to an unsigned int16 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U2_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_U2_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U4"/>:</para>
        ///   <para>"Convert to an unsigned int32 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U4() => Emit((ILOpCode)OpCodes.Conv_Ovf_U4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U4_Un"/>:</para>
        ///   <para>"Convert unsigned to an unsigned int32 (on the stack as int32) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U4_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_U4_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U8"/>:</para>
        ///   <para>"Convert to an unsigned int64 (on the stack as int64) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U8() => Emit((ILOpCode)OpCodes.Conv_Ovf_U8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_Ovf_U8_Un"/>:</para>
        ///   <para>"Convert unsigned to an unsigned int64 (on the stack as int64) and throw an exception on overflow."</para>
        /// </summary>
        public static void Conv_Ovf_U8_Un() => Emit((ILOpCode)OpCodes.Conv_Ovf_U8_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_R_Un"/>:</para>
        ///   <para>"Convert unsigned integer to floating-point, pushing F on stack."</para>
        /// </summary>
        public static void Conv_R_Un() => Emit((ILOpCode)OpCodes.Conv_R_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_R4"/>:</para>
        ///   <para>"Convert to float32, pushing F on stack."</para>
        /// </summary>
        public static void Conv_R4() => Emit((ILOpCode)OpCodes.Conv_R4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_R8"/>:</para>
        ///   <para>"Convert to float64, pushing F on stack."</para>
        /// </summary>
        public static void Conv_R8() => Emit((ILOpCode)OpCodes.Conv_R8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_U"/>:</para>
        ///   <para>"Convert to native unsigned int, pushing native int on stack."</para>
        /// </summary>
        public static void Conv_U() => Emit((ILOpCode)OpCodes.Conv_U.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_U1"/>:</para>
        ///   <para>"Convert to unsigned int8, pushing int32 on stack."</para>
        /// </summary>
        public static void Conv_U1() => Emit((ILOpCode)OpCodes.Conv_U1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_U2"/>:</para>
        ///   <para>"Convert to unsigned int16, pushing int32 on stack."</para>
        /// </summary>
        public static void Conv_U2() => Emit((ILOpCode)OpCodes.Conv_U2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_U4"/>:</para>
        ///   <para>"Convert to unsigned int32, pushing int32 on stack."</para>
        /// </summary>
        public static void Conv_U4() => Emit((ILOpCode)OpCodes.Conv_U4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Conv_U8"/>:</para>
        ///   <para>"Convert to unsigned int64, pushing int64 on stack."</para>
        /// </summary>
        public static void Conv_U8() => Emit((ILOpCode)OpCodes.Conv_U8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Cpblk"/>:</para>
        ///   <para>"Copy data from memory to memory."</para>
        /// </summary>
        public static void Cpblk() => Emit((ILOpCode)OpCodes.Cpblk.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Div"/>:</para>
        ///   <para>"Divide two values to return a quotient or floating-point result."</para>
        /// </summary>
        public static void Div() => Emit((ILOpCode)OpCodes.Div.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Div_Un"/>:</para>
        ///   <para>"Divide two values, unsigned, returning a quotient."</para>
        /// </summary>
        public static void Div_Un() => Emit((ILOpCode)OpCodes.Div_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Dup"/>:</para>
        ///   <para>"Duplicate the value on the top of the stack."</para>
        /// </summary>
        public static void Dup() => Emit((ILOpCode)OpCodes.Dup.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Endfilter"/>:</para>
        ///   <para>"End an exception handling filter clause."</para>
        /// </summary>
        public static void Endfilter() => Emit((ILOpCode)OpCodes.Endfilter.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Endfinally"/>:</para>
        ///   <para>"End finally clause of an exception block."</para>
        /// </summary>
        public static void Endfinally() => Emit((ILOpCode)OpCodes.Endfinally.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Initblk"/>:</para>
        ///   <para>"Set all bytes in a block of memory to a given byte value."</para>
        /// </summary>
        public static void Initblk() => Emit((ILOpCode)OpCodes.Initblk.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldarg_0"/>:</para>
        ///   <para>"Load argument 0 onto the stack."</para>
        /// </summary>
        public static void Ldarg_0() => Emit((ILOpCode)OpCodes.Ldarg_0.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldarg_1"/>:</para>
        ///   <para>"Load argument 1 onto the stack."</para>
        /// </summary>
        public static void Ldarg_1() => Emit((ILOpCode)OpCodes.Ldarg_1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldarg_2"/>:</para>
        ///   <para>"Load argument 2 onto the stack."</para>
        /// </summary>
        public static void Ldarg_2() => Emit((ILOpCode)OpCodes.Ldarg_2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldarg_3"/>:</para>
        ///   <para>"Load argument 3 onto the stack."</para>
        /// </summary>
        public static void Ldarg_3() => Emit((ILOpCode)OpCodes.Ldarg_3.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_0"/>:</para>
        ///   <para>"Push 0 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_0() => Emit((ILOpCode)OpCodes.Ldc_I4_0.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_1"/>:</para>
        ///   <para>"Push 1 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_1() => Emit((ILOpCode)OpCodes.Ldc_I4_1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_2"/>:</para>
        ///   <para>"Push 2 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_2() => Emit((ILOpCode)OpCodes.Ldc_I4_2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_3"/>:</para>
        ///   <para>"Push 3 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_3() => Emit((ILOpCode)OpCodes.Ldc_I4_3.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_4"/>:</para>
        ///   <para>"Push 4 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_4() => Emit((ILOpCode)OpCodes.Ldc_I4_4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_5"/>:</para>
        ///   <para>"Push 5 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_5() => Emit((ILOpCode)OpCodes.Ldc_I4_5.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_6"/>:</para>
        ///   <para>"Push 6 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_6() => Emit((ILOpCode)OpCodes.Ldc_I4_6.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_7"/>:</para>
        ///   <para>"Push 7 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_7() => Emit((ILOpCode)OpCodes.Ldc_I4_7.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_8"/>:</para>
        ///   <para>"Push 8 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_8() => Emit((ILOpCode)OpCodes.Ldc_I4_8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_M1"/>:</para>
        ///   <para>"Push -1 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4_M1() => Emit((ILOpCode)OpCodes.Ldc_I4_M1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_I"/>:</para>
        ///   <para>"Indirect load value of type native int as native int on the stack"</para>
        /// </summary>
        public static void Ldind_I() => Emit((ILOpCode)OpCodes.Ldind_I.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_I1"/>:</para>
        ///   <para>"Indirect load value of type int8 as int32 on the stack."</para>
        /// </summary>
        public static void Ldind_I1() => Emit((ILOpCode)OpCodes.Ldind_I1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_I2"/>:</para>
        ///   <para>"Indirect load value of type int16 as int32 on the stack."</para>
        /// </summary>
        public static void Ldind_I2() => Emit((ILOpCode)OpCodes.Ldind_I2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_I4"/>:</para>
        ///   <para>"Indirect load value of type int32 as int32 on the stack."</para>
        /// </summary>
        public static void Ldind_I4() => Emit((ILOpCode)OpCodes.Ldind_I4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_I8"/>:</para>
        ///   <para>"Indirect load value of type int64 as int64 on the stack."</para>
        /// </summary>
        public static void Ldind_I8() => Emit((ILOpCode)OpCodes.Ldind_I8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_R4"/>:</para>
        ///   <para>"Indirect load value of type float32 as F on the stack."</para>
        /// </summary>
        public static void Ldind_R4() => Emit((ILOpCode)OpCodes.Ldind_R4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_R8"/>:</para>
        ///   <para>"Indirect load value of type float64 as F on the stack."</para>
        /// </summary>
        public static void Ldind_R8() => Emit((ILOpCode)OpCodes.Ldind_R8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_Ref"/>:</para>
        ///   <para>"Indirect load value of type object ref as O on the stack."</para>
        /// </summary>
        public static void Ldind_Ref() => Emit((ILOpCode)OpCodes.Ldind_Ref.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_U1"/>:</para>
        ///   <para>"Indirect load value of type unsigned int8 as int32 on the stack"</para>
        /// </summary>
        public static void Ldind_U1() => Emit((ILOpCode)OpCodes.Ldind_U1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_U2"/>:</para>
        ///   <para>"Indirect load value of type unsigned int16 as int32 on the stack"</para>
        /// </summary>
        public static void Ldind_U2() => Emit((ILOpCode)OpCodes.Ldind_U2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldind_U4"/>:</para>
        ///   <para>"Indirect load value of type unsigned int32 as int32 on the stack"</para>
        /// </summary>
        public static void Ldind_U4() => Emit((ILOpCode)OpCodes.Ldind_U4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldlen"/>:</para>
        ///   <para>"Push the length (of type native unsigned int) of array on the stack."</para>
        /// </summary>
        public static void Ldlen() => Emit((ILOpCode)OpCodes.Ldlen.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldloc_0"/>:</para>
        ///   <para>"Load local variable 0 onto stack."</para>
        /// </summary>
        public static void Ldloc_0() => Emit((ILOpCode)OpCodes.Ldloc_0.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldloc_1"/>:</para>
        ///   <para>"Load local variable 1 onto stack."</para>
        /// </summary>
        public static void Ldloc_1() => Emit((ILOpCode)OpCodes.Ldloc_1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldloc_2"/>:</para>
        ///   <para>"Load local variable 2 onto stack."</para>
        /// </summary>
        public static void Ldloc_2() => Emit((ILOpCode)OpCodes.Ldloc_2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldloc_3"/>:</para>
        ///   <para>"Load local variable 3 onto stack."</para>
        /// </summary>
        public static void Ldloc_3() => Emit((ILOpCode)OpCodes.Ldloc_3.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldnull"/>:</para>
        ///   <para>"Push a null reference on the stack."</para>
        /// </summary>
        public static void Ldnull() => Emit((ILOpCode)OpCodes.Ldnull.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Localloc"/>:</para>
        ///   <para>"Allocate space from the local memory pool."</para>
        /// </summary>
        public static void Localloc() => Emit((ILOpCode)OpCodes.Localloc.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Mul"/>:</para>
        ///   <para>"Multiply values."</para>
        /// </summary>
        public static void Mul() => Emit((ILOpCode)OpCodes.Mul.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Mul_Ovf"/>:</para>
        ///   <para>"Multiply signed integer values. Signed result shall fit in same size"</para>
        /// </summary>
        public static void Mul_Ovf() => Emit((ILOpCode)OpCodes.Mul_Ovf.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Mul_Ovf_Un"/>:</para>
        ///   <para>"Multiply unsigned integer values. Unsigned result shall fit in same size"</para>
        /// </summary>
        public static void Mul_Ovf_Un() => Emit((ILOpCode)OpCodes.Mul_Ovf_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Neg"/>:</para>
        ///   <para>"Negate value."</para>
        /// </summary>
        public static void Neg() => Emit((ILOpCode)OpCodes.Neg.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Nop"/>:</para>
        ///   <para>"Do nothing (No operation)."</para>
        /// </summary>
        public static void Nop() => Emit((ILOpCode)OpCodes.Nop.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Not"/>:</para>
        ///   <para>"Bitwise complement (logical not)."</para>
        /// </summary>
        public static void Not() => Emit((ILOpCode)OpCodes.Not.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Or"/>:</para>
        ///   <para>"Bitwise OR of two integer values, returns an integer."</para>
        /// </summary>
        public static void Or() => Emit((ILOpCode)OpCodes.Or.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Pop"/>:</para>
        ///   <para>"Pop value from the stack."</para>
        /// </summary>
        public static void Pop() => Emit((ILOpCode)OpCodes.Pop.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Readonly"/>:</para>
        ///   <para>"Specify that the subsequent array address operation performs no type check at runtime, and that it returns a controlled-mutability managed pointer"</para>
        /// </summary>
        public static void Readonly() => Emit((ILOpCode)OpCodes.Readonly.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Refanytype"/>:</para>
        ///   <para>"Push the type token stored in a typed reference."</para>
        /// </summary>
        public static void Refanytype() => Emit((ILOpCode)OpCodes.Refanytype.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Rem"/>:</para>
        ///   <para>"Remainder when dividing one value by another."</para>
        /// </summary>
        public static void Rem() => Emit((ILOpCode)OpCodes.Rem.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Rem_Un"/>:</para>
        ///   <para>"Remainder when dividing one unsigned value by another."</para>
        /// </summary>
        public static void Rem_Un() => Emit((ILOpCode)OpCodes.Rem_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ret"/>:</para>
        ///   <para>"Return from method, possibly with a value."</para>
        /// </summary>
        public static void Ret() => Emit((ILOpCode)OpCodes.Ret.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Rethrow"/>:</para>
        ///   <para>"Rethrow the current exception."</para>
        /// </summary>
        public static void Rethrow() => Emit((ILOpCode)OpCodes.Rethrow.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Shl"/>:</para>
        ///   <para>"Shift an integer left (shifting in zeros), return an integer."</para>
        /// </summary>
        public static void Shl() => Emit((ILOpCode)OpCodes.Shl.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Shr"/>:</para>
        ///   <para>"Shift an integer right (shift in sign), return an integer."</para>
        /// </summary>
        public static void Shr() => Emit((ILOpCode)OpCodes.Shr.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Shr_Un"/>:</para>
        ///   <para>"Shift an integer right (shift in zero), return an integer."</para>
        /// </summary>
        public static void Shr_Un() => Emit((ILOpCode)OpCodes.Shr_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_I"/>:</para>
        ///   <para>"Store value of type native int into memory at address"</para>
        /// </summary>
        public static void Stind_I() => Emit((ILOpCode)OpCodes.Stind_I.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_I1"/>:</para>
        ///   <para>"Store value of type int8 into memory at address"</para>
        /// </summary>
        public static void Stind_I1() => Emit((ILOpCode)OpCodes.Stind_I1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_I2"/>:</para>
        ///   <para>"Store value of type int16 into memory at address"</para>
        /// </summary>
        public static void Stind_I2() => Emit((ILOpCode)OpCodes.Stind_I2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_I4"/>:</para>
        ///   <para>"Store value of type int32 into memory at address"</para>
        /// </summary>
        public static void Stind_I4() => Emit((ILOpCode)OpCodes.Stind_I4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_I8"/>:</para>
        ///   <para>"Store value of type int64 into memory at address"</para>
        /// </summary>
        public static void Stind_I8() => Emit((ILOpCode)OpCodes.Stind_I8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_R4"/>:</para>
        ///   <para>"Store value of type float32 into memory at address"</para>
        /// </summary>
        public static void Stind_R4() => Emit((ILOpCode)OpCodes.Stind_R4.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_R8"/>:</para>
        ///   <para>"Store value of type float64 into memory at address"</para>
        /// </summary>
        public static void Stind_R8() => Emit((ILOpCode)OpCodes.Stind_R8.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stind_Ref"/>:</para>
        ///   <para>"Store value of type object ref (type O) into memory at address"</para>
        /// </summary>
        public static void Stind_Ref() => Emit((ILOpCode)OpCodes.Stind_Ref.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stloc_0"/>:</para>
        ///   <para>"Pop a value from stack into local variable 0."</para>
        /// </summary>
        public static void Stloc_0() => Emit((ILOpCode)OpCodes.Stloc_0.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stloc_1"/>:</para>
        ///   <para>"Pop a value from stack into local variable 1."</para>
        /// </summary>
        public static void Stloc_1() => Emit((ILOpCode)OpCodes.Stloc_1.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stloc_2"/>:</para>
        ///   <para>"Pop a value from stack into local variable 2."</para>
        /// </summary>
        public static void Stloc_2() => Emit((ILOpCode)OpCodes.Stloc_2.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stloc_3"/>:</para>
        ///   <para>"Pop a value from stack into local variable 3."</para>
        /// </summary>
        public static void Stloc_3() => Emit((ILOpCode)OpCodes.Stloc_3.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Sub"/>:</para>
        ///   <para>"Subtract value2 from value1, returning a new value."</para>
        /// </summary>
        public static void Sub() => Emit((ILOpCode)OpCodes.Sub.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Sub_Ovf"/>:</para>
        ///   <para>"Subtract native int from a native int. Signed result shall fit in same size"</para>
        /// </summary>
        public static void Sub_Ovf() => Emit((ILOpCode)OpCodes.Sub_Ovf.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Sub_Ovf_Un"/>:</para>
        ///   <para>"Subtract native unsigned int from a native unsigned int. Unsigned result shall fit in same size."</para>
        /// </summary>
        public static void Sub_Ovf_Un() => Emit((ILOpCode)OpCodes.Sub_Ovf_Un.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Throw"/>:</para>
        ///   <para>"Throw an exception."</para>
        /// </summary>
        public static void Throw() => Emit((ILOpCode)OpCodes.Throw.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Volatile"/>:</para>
        ///   <para>"Subsequent pointer reference is volatile."</para>
        /// </summary>
        public static void Volatile() => Emit((ILOpCode)OpCodes.Volatile.Value);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Xor"/>:</para>
        ///   <para>"Bitwise XOR of integer values, returns an integer."</para>
        /// </summary>
        public static void Xor() => Emit((ILOpCode)OpCodes.Xor.Value);

        #endregion //

        #region string target
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Beq"/>:</para>
        ///   <para>"Branch to target if equal."</para>
        /// </summary>
        public static void Beq(string target) => Emit((ILOpCode)OpCodes.Beq.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Beq_S"/>:</para>
        ///   <para>"Branch to target if equal, short form."</para>
        /// </summary>
        public static void Beq_S(string target) => Emit((ILOpCode)OpCodes.Beq_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bge"/>:</para>
        ///   <para>"Branch to target if greater than or equal to."</para>
        /// </summary>
        public static void Bge(string target) => Emit((ILOpCode)OpCodes.Bge.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bge_S"/>:</para>
        ///   <para>"Branch to target if greater than or equal to, short form."</para>
        /// </summary>
        public static void Bge_S(string target) => Emit((ILOpCode)OpCodes.Bge_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bge_Un"/>:</para>
        ///   <para>"Branch to target if greater than or equal to (unsigned or unordered)."</para>
        /// </summary>
        public static void Bge_Un(string target) => Emit((ILOpCode)OpCodes.Bge_Un.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bge_Un_S"/>:</para>
        ///   <para>"Branch to target if greater than or equal to (unsigned or unordered), short form"</para>
        /// </summary>
        public static void Bge_Un_S(string target) => Emit((ILOpCode)OpCodes.Bge_Un_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bgt"/>:</para>
        ///   <para>"Branch to target if greater than."</para>
        /// </summary>
        public static void Bgt(string target) => Emit((ILOpCode)OpCodes.Bgt.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bgt_S"/>:</para>
        ///   <para>"Branch to target if greater than, short form."</para>
        /// </summary>
        public static void Bgt_S(string target) => Emit((ILOpCode)OpCodes.Bgt_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bgt_Un"/>:</para>
        ///   <para>"Branch to target if greater than (unsigned or unordered)."</para>
        /// </summary>
        public static void Bgt_Un(string target) => Emit((ILOpCode)OpCodes.Bgt_Un.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bgt_Un_S"/>:</para>
        ///   <para>"Branch to target if greater than (unsigned or unordered), short form."</para>
        /// </summary>
        public static void Bgt_Un_S(string target) => Emit((ILOpCode)OpCodes.Bgt_Un_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ble"/>:</para>
        ///   <para>"Branch to target if less than or equal to."</para>
        /// </summary>
        public static void Ble(string target) => Emit((ILOpCode)OpCodes.Ble.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ble_S"/>:</para>
        ///   <para>"Branch to target if less than or equal to, short form."</para>
        /// </summary>
        public static void Ble_S(string target) => Emit((ILOpCode)OpCodes.Ble_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ble_Un"/>:</para>
        ///   <para>"Branch to target if less than or equal to (unsigned or unordered)."</para>
        /// </summary>
        public static void Ble_Un(string target) => Emit((ILOpCode)OpCodes.Ble_Un.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ble_Un_S"/>:</para>
        ///   <para>"Branch to target if less than or equal to (unsigned or unordered), short form"</para>
        /// </summary>
        public static void Ble_Un_S(string target) => Emit((ILOpCode)OpCodes.Ble_Un_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Blt"/>:</para>
        ///   <para>"Branch to target if less than."</para>
        /// </summary>
        public static void Blt(string target) => Emit((ILOpCode)OpCodes.Blt.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Blt_S"/>:</para>
        ///   <para>"Branch to target if less than, short form."</para>
        /// </summary>
        public static void Blt_S(string target) => Emit((ILOpCode)OpCodes.Blt_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Blt_Un"/>:</para>
        ///   <para>"Branch to target if less than (unsigned or unordered)."</para>
        /// </summary>
        public static void Blt_Un(string target) => Emit((ILOpCode)OpCodes.Blt_Un.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Blt_Un_S"/>:</para>
        ///   <para>"Branch to target if less than (unsigned or unordered), short form."</para>
        /// </summary>
        public static void Blt_Un_S(string target) => Emit((ILOpCode)OpCodes.Blt_Un_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bne_Un"/>:</para>
        ///   <para>"Branch to target if unequal or unordered."</para>
        /// </summary>
        public static void Bne_Un(string target) => Emit((ILOpCode)OpCodes.Bne_Un.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Bne_Un_S"/>:</para>
        ///   <para>"Branch to target if unequal or unordered, short form."</para>
        /// </summary>
        public static void Bne_Un_S(string target) => Emit((ILOpCode)OpCodes.Bne_Un_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Br"/>:</para>
        ///   <para>"Branch to target."</para>
        /// </summary>
        public static void Br(string target) => Emit((ILOpCode)OpCodes.Br.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Br_S"/>:</para>
        ///   <para>"Branch to target, short form."</para>
        /// </summary>
        public static void Br_S(string target) => Emit((ILOpCode)OpCodes.Br_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Brfalse"/>:</para>
        ///   <para>"Branch to target if value is zero (false)."</para>
        /// </summary>
        public static void Brfalse(string target) => Emit((ILOpCode)OpCodes.Brfalse.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Brfalse_S"/>:</para>
        ///   <para>"Branch to target if value is zero (false), short form."</para>
        /// </summary>
        public static void Brfalse_S(string target) => Emit((ILOpCode)OpCodes.Brfalse_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Brtrue"/>:</para>
        ///   <para>"Branch to target if value is non-zero (true)."</para>
        /// </summary>
        public static void Brtrue(string target) => Emit((ILOpCode)OpCodes.Brtrue.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Brtrue_S"/>:</para>
        ///   <para>"Branch to target if value is non-zero (true), short form."</para>
        /// </summary>
        public static void Brtrue_S(string target) => Emit((ILOpCode)OpCodes.Brtrue_S.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Leave"/>:</para>
        ///   <para>"Exit a protected region of code."</para>
        /// </summary>
        public static void Leave(string target) => Emit((ILOpCode)OpCodes.Leave.Value, target);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Leave_S"/>:</para>
        ///   <para>"Exit a protected region of code, short form."</para>
        /// </summary>
        public static void Leave_S(string target) => Emit((ILOpCode)OpCodes.Leave_S.Value, target);

        #endregion // string target

        #region Type type
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Box"/>:</para>
        ///   <para>"Convert a boxable value to its boxed form"</para>
        /// </summary>
        public static void Box(Type type) => Emit((ILOpCode)OpCodes.Box.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Castclass"/>:</para>
        ///   <para>"Cast obj to class."</para>
        /// </summary>
        public static void Castclass(Type type) => Emit((ILOpCode)OpCodes.Castclass.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Constrained"/>:</para>
        ///   <para>"Call a virtual method on a type constrained to be type T"</para>
        /// </summary>
        public static void Constrained(Type type) => Emit((ILOpCode)OpCodes.Constrained.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Cpobj"/>:</para>
        ///   <para>"Copy a value type from src to dest."</para>
        /// </summary>
        public static void Cpobj(Type type) => Emit((ILOpCode)OpCodes.Cpobj.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Initobj"/>:</para>
        ///   <para>"Initialize the value at address dest."</para>
        /// </summary>
        public static void Initobj(Type type) => Emit((ILOpCode)OpCodes.Initobj.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Isinst"/>:</para>
        ///   <para>"Test if obj is an instance of class, returning null or an instance of that class or interface."</para>
        /// </summary>
        public static void Isinst(Type type) => Emit((ILOpCode)OpCodes.Isinst.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldobj"/>:</para>
        ///   <para>"Copy the value stored at address src to the stack."</para>
        /// </summary>
        public static void Ldobj(Type type) => Emit((ILOpCode)OpCodes.Ldobj.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Mkrefany"/>:</para>
        ///   <para>"Push a typed reference to ptr of type class onto the stack."</para>
        /// </summary>
        public static void Mkrefany(Type type) => Emit((ILOpCode)OpCodes.Mkrefany.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Refanyval"/>:</para>
        ///   <para>"Push the address stored in a typed reference."</para>
        /// </summary>
        public static void Refanyval(Type type) => Emit((ILOpCode)OpCodes.Refanyval.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Sizeof"/>:</para>
        ///   <para>"Push the size, in bytes, of a type as an unsigned int32."</para>
        /// </summary>
        public static void Sizeof(Type type) => Emit((ILOpCode)OpCodes.Sizeof.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stobj"/>:</para>
        ///   <para>"Store a value of type typeTok at an address."</para>
        /// </summary>
        public static void Stobj(Type type) => Emit((ILOpCode)OpCodes.Stobj.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Unbox"/>:</para>
        ///   <para>"Extract a value-type from obj, its boxed representation."</para>
        /// </summary>
        public static void Unbox(Type type) => Emit((ILOpCode)OpCodes.Unbox.Value, type);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Unbox_Any"/>:</para>
        ///   <para>"Extract a value-type from obj, its boxed representation"</para>
        /// </summary>
        public static void Unbox_Any(Type type) => Emit((ILOpCode)OpCodes.Unbox_Any.Value, type);

        #endregion // Type type

        #region object methodCall
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Call"/>:</para>
        ///   <para>"Call method described by method."</para>
        /// </summary>
        public static void Call(object methodCall) => Emit((ILOpCode)OpCodes.Call.Value, methodCall);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Callvirt"/>:</para>
        ///   <para>"Call a method associated with an object."</para>
        /// </summary>
        public static void Callvirt(object methodCall) => Emit((ILOpCode)OpCodes.Callvirt.Value, methodCall);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Jmp"/>:</para>
        ///   <para>"Exit current method and jump to the specified method."</para>
        /// </summary>
        public static void Jmp(object methodCall) => Emit((ILOpCode)OpCodes.Jmp.Value, methodCall);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldftn"/>:</para>
        ///   <para>"Push a pointer to a method referenced by method, on the stack."</para>
        /// </summary>
        public static void Ldftn(object methodCall) => Emit((ILOpCode)OpCodes.Ldftn.Value, methodCall);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldvirtftn"/>:</para>
        ///   <para>"Push address of virtual method on the stack."</para>
        /// </summary>
        public static void Ldvirtftn(object methodCall) => Emit((ILOpCode)OpCodes.Ldvirtftn.Value, methodCall);

        #endregion // object methodCall

        #region byte nbr
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldarg_S"/>:</para>
        ///   <para>"Load argument numbered num onto the stack, short form."</para>
        /// </summary>
        public static void Ldarg_S(byte nbr) => Emit((ILOpCode)OpCodes.Ldarg_S.Value, nbr);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldarga_S"/>:</para>
        ///   <para>"Fetch the address of argument argNum, short form."</para>
        /// </summary>
        public static void Ldarga_S(byte nbr) => Emit((ILOpCode)OpCodes.Ldarga_S.Value, nbr);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldloc_S"/>:</para>
        ///   <para>"Load local variable of index indx onto stack, short form."</para>
        /// </summary>
        public static void Ldloc_S(byte nbr) => Emit((ILOpCode)OpCodes.Ldloc_S.Value, nbr);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldloca_S"/>:</para>
        ///   <para>"Load address of local variable with index indx, short form."</para>
        /// </summary>
        public static void Ldloca_S(byte nbr) => Emit((ILOpCode)OpCodes.Ldloca_S.Value, nbr);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Starg_S"/>:</para>
        ///   <para>"Store value to the argument numbered num, short form."</para>
        /// </summary>
        public static void Starg_S(byte nbr) => Emit((ILOpCode)OpCodes.Starg_S.Value, nbr);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stloc_S"/>:</para>
        ///   <para>"Pop a value from stack into local variable indx, short form."</para>
        /// </summary>
        public static void Stloc_S(byte nbr) => Emit((ILOpCode)OpCodes.Stloc_S.Value, nbr);

        #endregion // byte nbr

        #region int nbr
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4"/>:</para>
        ///   <para>"Push num of type int32 onto the stack as int32."</para>
        /// </summary>
        public static void Ldc_I4(int nbr) => Emit((ILOpCode)OpCodes.Ldc_I4.Value, nbr);

        #endregion // int nbr

        #region sbyte nbr
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I4_S"/>:</para>
        ///   <para>"Push num onto the stack as int32, short form."</para>
        /// </summary>
        public static void Ldc_I4_S(sbyte nbr) => Emit((ILOpCode)OpCodes.Ldc_I4_S.Value, nbr);

        #endregion // sbyte nbr

        #region long nbr
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_I8"/>:</para>
        ///   <para>"Push num of type int64 onto the stack as int64."</para>
        /// </summary>
        public static void Ldc_I8(long nbr) => Emit((ILOpCode)OpCodes.Ldc_I8.Value, nbr);

        #endregion // long nbr

        #region float nbr
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_R4"/>:</para>
        ///   <para>"Push num of type float32 onto the stack as F."</para>
        /// </summary>
        public static void Ldc_R4(float nbr) => Emit((ILOpCode)OpCodes.Ldc_R4.Value, nbr);

        #endregion // float nbr

        #region double nbr
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldc_R8"/>:</para>
        ///   <para>"Push num of type float64 onto the stack as F."</para>
        /// </summary>
        public static void Ldc_R8(double nbr) => Emit((ILOpCode)OpCodes.Ldc_R8.Value, nbr);

        #endregion // double nbr

        #region object fieldAccess
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldfld"/>:</para>
        ///   <para>"Push the value of field of object (or value type) obj, onto the stack."</para>
        /// </summary>
        public static void Ldfld(object fieldAccess) => Emit((ILOpCode)OpCodes.Ldfld.Value, fieldAccess);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldflda"/>:</para>
        ///   <para>"Push the address of field of object obj on the stack."</para>
        /// </summary>
        public static void Ldflda(object fieldAccess) => Emit((ILOpCode)OpCodes.Ldflda.Value, fieldAccess);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldsfld"/>:</para>
        ///   <para>"Push the value of field on the stack."</para>
        /// </summary>
        public static void Ldsfld(object fieldAccess) => Emit((ILOpCode)OpCodes.Ldsfld.Value, fieldAccess);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldsflda"/>:</para>
        ///   <para>"Push the address of the static field, field, on the stack."</para>
        /// </summary>
        public static void Ldsflda(object fieldAccess) => Emit((ILOpCode)OpCodes.Ldsflda.Value, fieldAccess);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stfld"/>:</para>
        ///   <para>"Replace the value of field of the object obj with value."</para>
        /// </summary>
        public static void Stfld(object fieldAccess) => Emit((ILOpCode)OpCodes.Stfld.Value, fieldAccess);

        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Stsfld"/>:</para>
        ///   <para>"Replace the value of field with val."</para>
        /// </summary>
        public static void Stsfld(object fieldAccess) => Emit((ILOpCode)OpCodes.Stsfld.Value, fieldAccess);

        #endregion // object fieldAccess

        #region string str
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Ldstr"/>:</para>
        ///   <para>"Push a string object for the literal string."</para>
        /// </summary>
        public static void Ldstr(string str) => Emit((ILOpCode)OpCodes.Ldstr.Value, str);

        #endregion // string str

        #region Type itemType
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Newarr"/>:</para>
        ///   <para>"Create a new array with elements of type etype."</para>
        /// </summary>
        public static void Newarr(Type itemType) => Emit((ILOpCode)OpCodes.Newarr.Value, itemType);

        #endregion // Type itemType

        #region object ctorCall
        /// <summary>
        ///   <para>Prints <see cref="OpCodes.Newobj"/>:</para>
        ///   <para>"Allocate an uninitialized object or value type and call ctor."</para>
        /// </summary>
        public static void Newobj(object ctorCall) => Emit((ILOpCode)OpCodes.Newobj.Value, ctorCall);

        #endregion // object ctorCall

    }
}


text:
using System;
using System.IO;
using System.Net;

namespace AssembliesAndNamespaces
{
    class Program
    {
        static void Main(string[] args)
        {
            WebClient client = new WebClient();
            string reply = client.DownloadString("http://msdn.microsoft.com");

            Console.WriteLine(reply);
            File.WriteAllText(@"C:\Lesson17\WriteText.txt", reply);
            Console.ReadLine();
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
/**
* ViewManager module
*
* @module enyo/ViewManager
* @wip
*/

/**
* Fires after a view has been created and rendered, if necessary, but before it transitions into
* viewport.
*
* @event module:enyo/ViewManager~ViewManager#activate
* @property {module:enyo/Control~Control} view The target view for the event
* @property {Boolean} dragging `true` for `activate` or `deactivate` events that occur as a result
*	of dragging
* @property {Number} direction Either 1 representing forward or -1 representing backward
* @public
*/

/**
* Fires after a view has been created, rendered, and transitioned into the viewport.
*
* @event module:enyo/ViewManager~ViewManager#activated
* @type {Object}
* @property {module:enyo/Control~Control} view The target view for the event
* @property {Boolean} dragging `true` for `activate` or `deactivate` events that occur as a result
*	of dragging
* @property {Number} direction Either 1 representing forward or -1 representing backward
* @public
*/

/**
* Fires on the previously active view when a new view has become active but before it has
* transitioned out of the viewport
*
* @event module:enyo/ViewManager~ViewManager#deactivate
* @property {module:enyo/Control~Control} view The target view for the event
* @property {Boolean} dragging `true` for `activate` or `deactivate` events that occur as a result
*	of dragging
* @property {Number} direction Either 1 representing forward or -1 representing backward
* @public
*/

/**
* Fires on the previously active view when it has transitioned out of the viewport and been torn
* down.
*
* @event module:enyo/ViewManager~ViewManager#deactivated
* @property {module:enyo/Control~Control} view The target view for the event
* @property {Boolean} dragging `true` for `activate` or `deactivate` events that occur as a result
*	of dragging
* @property {Number} direction Either 1 representing forward or -1 representing backward
* @public
*/

/**
* Fires on the previously active view when it has transitioned out of the viewport and been torn
* down.
*
* @event module:enyo/ViewManager~ViewManager#deactivated
* @property {module:enyo/Control~Control} view The target view for the event
* @property {Boolean} dragging `true` for `activate` or `deactivate` events that occur as a result
*	of dragging
* @property {Number} direction Either 1 representing forward or -1 representing backward
* @public
*/

/**
* Fires when this ViewManager is [activated]{@link module:enyo/ViewManager~ViewManager#activate} by
* its [manager]{@link module:enyo/ViewManager~ViewManager#manager} and ready to activate its own
* views.
*
* @event module:enyo/ViewManager~ViewManager#manage
* @public
*/

/**
* Fires when this ViewManager dimissal is initiated -- either by a call to
* [dismiss()]{@link module:enyo/ViewManager~ViewManager#dismiss} or when a
* [dismissable]{@link module:enyo/ViewManager~ViewManager#dismissable} ViewManager is on its first
* view and is dragged beyond the
* [dragThreshold]{@link module:enyo/ViewManager~ViewManager#dragThreshold}.
*
* @event module:enyo/ViewManager~ViewManager#dismiss
* @property {Boolean} dragging `true` for when dismissing as a result of dragging
* @public
*/

/**
* Fires when a ViewManager completes its dismissal.
*
* @event module:enyo/ViewManager~ViewManager#dismissed
* @public
*/

var
	animation = require('../animation'),
	kind = require('../kind'),
	utils = require('../utils'),
	Control = require('../Control'),
	EventEmitter = require('../EventEmitter'),
	SlideViewLayout = require('../SlideViewLayout'),
	rAF = animation.requestAnimationFrame;

var
	ScrimSupport = require('./ScrimSupport');

var viewCount = 0;

/**
* ViewManager manages views.
*
* ```
* module.exports = kind({
*	kind: ViewManager,
*	classes: 'contacts',
*
*	// All the views are declared in the common components block
*	components: [
*		{name: 'history', components: [
*			{content: 'History'},
*			{kind: Button, content: 'Next', ontap: 'next'}
*		]},
*		{name: 'dialer', active: true, components: [
*			{content: 'Dialer'},
*			{kind: Button, content: 'Inline Example', ontap: 'activateInline'},
*			{kind: Button, content: 'Previous', ontap: 'previous'},
*			{kind: Button, content: 'Next', ontap: 'next'}
*		]},
*		{name: 'contacts', components: [
*			{content: 'Contacts'},
*			{kind: Button, content: 'Previous', ontap: 'previous'},
*			{kind: Button, content: 'Add A Contact', ontap: 'pushAddContactView'}
*		]}
*	],
*
*	// Child ViewManagers are declared within a new managers block
*	managers: [
*		{name: 'add', kind: AddContact},
*		{name: 'inline', kind: ViewManager, floating: true, components: [
*			{content: 'view1', style: 'background: #424242; color: #fff;', ontap: 'nextInline'},
*			{content: 'view2', style: 'background: #424242; color: #fff;', ontap: 'nextInline'},
*			{content: 'view3', style: 'background: #424242; color: #fff;', ontap: 'dismissInline'}
*		]}
*	],
*
*	create: function () {
*		ViewManager.prototype.create.apply(this, arguments);
*
*		function log (sender, name, event) {
*			console.log('Event', name,
*				'on view', event.view.name,
*				event.dragging ? 'while dragging' : '');
*		}
*
*		// ViewManager emits events to ease view initialization and teardown without concern for the
*		// async nature of animations.
*
*		// `view` has been activated but not animated
*		this.on('activate', log);
*
*		// `view` has been activate and animated
*		this.on('activated', log);
*
*		// `view` has been deactivated but not animated
*		this.on('deactivate', log);
*
*		// `view` has been deactivated and animated
*		this.on('deactivated', log);
*	},
*
*	// Activate and navigate the Inline ViewManager
*	activateInline: function () {
*		this.activate('inline');
*	},
*	nextInline: function () {
*		this.$.inline.next();
*	},
*	dismissInline: function () {
*		this.$.inline.dismiss();
*	},
*
*	// Activate the Contacts ViewManager
*	pushAddContactView: function () {
*		var view = this.activate('add');
*		view.set('model', new Model({
*			first: 'First Name',
*			last: 'Last Name'
*		}));
*	}
* });
* ```
*
* @class ViewManager
* @extends module:enyo/Control~Control
* @ui
* @public
* @wip
*/
var ViewMgr = kind(
	/** @lends module:enyo/ViewManager~ViewManager.prototype */ {

	/**
	* @private
	*/
	kind: Control,

	/**
	* @private
	*/
	layoutKind: SlideViewLayout,

	/**
	* @private
	*/
	mixins: [EventEmitter],

	/**
	* @private
	*/
	animate: true,

	/**
	* @private
	*/
	classes: 'enyo-viewmanager',

	// PUBLIC PROPERTIES

	/**
	* Determines if and how the default view is activated. The default view is either the first
	* view with a truthy `active` member or the first view if none are marked active.
	*
	* * 'off' - No view is activated by default
	* * 'create' - The default view is activated on create and not animated into position
	* * 'render' - The default view is activated on render and animated into position
	* * 'auto' - For floating ViewManagers, this is equivalent to 'render'. For non-floating
	*   ViewManagers, this is equivalent to 'create'.
	*
	* @type {String}
	* @default auto
	* @public
	*/
	activateDefault: 'auto',

	/**
	* Determines if the view can be dismissed by dragging. The ViewManager can be programmatically
	* dismissed via dismiss() regardless of the value of this property. If the ViewManager is the
	* root and does not have a `manager`, it cannot be dismissed by dragging or by `dismiss()`.
	*
	* * `true` - Can be dismissed
	* * `false` - Cannot be dismissed
	* * 'auto' - Can be dismissed if `floating` is `true`
	*
	* @type {Boolean|String}
	* @default auto
	* @public
	*/
	dismissable: 'auto',

	/**
	* When `true`, the views can be dragged or flicked into and out of view.
	* When `false`, the views cannot be dragged or flicked.
	* When `drag`, the views can *only* be dragged and not flicked.
	* When `flick`, the views can *only* be flicked and not dragged.
	*
	* @type {Boolean|String}
	* @default true
	* @public
	*/
	draggable: true,

	/**
	* Percent a new view must be dragged into the viewport to be activated on drag release
	*
	* @type {Number}
	* @default 25
	* @public
	*/
	dragThreshold: 25,

	/**
	* If `true`, this ViewManager 'floats' over its parent `manager`
	*
	* @type {Boolean}
	* @default false
	* @public
	*/
	floating: false,

	/**
	* If created within another ViewManager, `manager` will maintain a reference to that
	* ViewManager which will be notified of activated, deactivated, dismiss, and dismissed events
	* from this ViewManager.
	*
	* @type {module:enyo/ViewManager~ViewManager}
	* @default null
	* @public
	*/
	manager: null,

	/**
	* @private
	*/
	managerChanged: function (was, is) {
		if (was) this.off('*', was.managerEvent);
		if (is) this.on('*', is.managerEvent);
	},

	/**
	* When `draggable`, this constrains the drag to this direction.
	*
	* @type {String}
	* @default horizontal
	* @public
	*/
	orientation: 'horizontal',

	/**
	* The number of views managed by this ViewManager. This member is observable but should be
	* considered read-only.
	*
	* @type {Number}
	* @default 0
	* @readOnly
	* @public
	*/
	viewCount: 0,

	// PRIVATE PROPERTIES

	/**
	* Active view
	*
	* @type {module:enyo/Control~Control}
	* @private
	*/
	active: null,

	/**
	* @private
	*/
	activeChanged: function (was, is) {
		if (was) {
			if (this.dragging) {
				this.set('dragging', false);
				this.releaseDraggedView = was.retainNode();
			}
			this.emitViewEvent('deactivate', was);
		}
	},

	/**
	* Indicates the logical direction of a view activation. May be used by ViewLayouts to inform the
	* direction of their animation
	*
	* @type {Number}
	* @default 0
	* @private
	*/
	direction: 0,

	/**
	* `true` when this ViewManager has been dismissed
	*
	* @type {Boolean}
	* @default false
	* @private
	*/
	dismissed: false,

	/**
	* `true` when a drag gesture is in process
	*
	* @type {Boolean}
	* @default false
	* @private
	*/
	dragging: false,

	/**
	* During a drag, contains a reference to the becoming-active view
	*
	* @private
	*/
	dragView: null,

	/**
	* @type {Boolean}
	*/
	flicked: false,

	/**
	* @private
	*/
	layoutKindChanged: function (was, is) {
		Control.prototype.layoutKindChanged.apply(this, arguments);
		if (this.layout && this.layout.on) {
			this.layout.on('complete', this.handleLayoutComplete, this);
		}
	},

	/**
	* @private
	*/
	handlers: {
		onflick: 'handleFlick',
		ondown: 'handleDown',
		ondragstart: 'handleDragStart',
		ondrag: 'handleDrag',
		ondragfinish: 'handleDragFinish'
	},

	/**
	* @private
	*/
	create: function () {
		// Set layoutCover for floating ViewManagers that haven't explicitly defined it
		if (this.floating && this.layoutCover === undefined) this.layoutCover = true;

		this.on('*', this.notifyViews, this);
		Control.prototype.create.apply(this, arguments);

		// cache a bound reference to the managerEvent handler
		this.managerEvent = this.managerEvent.bind(this);
		this.managerChanged(null, this.manager);

		if (this.floating) this.stack = [];

		if (this.activateDefault == 'create' || (this.activateDefault == 'auto' && !this.floating)) {
			this.initFirstView();
		}
	},

	/**
	* @private
	*/
	rendered: function () {
		Control.prototype.rendered.apply(this, arguments);
		if (this.activateDefault == 'render' || (this.activateDefault == 'auto' && this.floating)) {
			this.initFirstView();
		}
		this.set('dismissed', false);
	},

	/**
	* @private
	*/
	initComponents: function () {
		var managersOwner = this.hasOwnProperty('managers') ? this.getInstanceOwner() : this;

		// view configs or instances
		this.views = [];
		this.viewManagers = {};

		// map of view name to index
		this.viewNames = {};

		// import kind and user components into this.views
		this.importViewConfig(this.kindComponents, this);
		this.importViewConfig(this.components, this.getInstanceOwner());
		this.importViewConfig(this.managers, managersOwner, true);
		this.viewCount = this.views.length;

		// clean up references
		this.components = this.kindComponents = null;
	},

	/**
	* If a newly added control doesn't exist in the view or manager array, add it
	*
	* @private
	*/
	addControl: function (control, before) {
		var viewIndex = this.viewNames[control.name];
		Control.prototype.addControl.apply(this, arguments);

		if (!control.isChrome && !(viewIndex || viewIndex === 0) && !this.viewManagers[control.name]) {
			this.addView(control);
			this.set('viewCount', this.views.length);
		}
	},

	/**
	* @private
	*/
	removeControl: function (control) {
		var i, l,
			index = this.views.indexOf(control);

		Control.prototype.removeControl.apply(this, arguments);
		if (index >= 0) {
			this.views.splice(index, 1);
			this.viewNames[control.name] = null;

			for (i = index, l = this.views.length; i < l; i++) {
				this.viewNames[this.views[i].name] = i;
			}
			this.set('viewCount', this.viewCount - 1);
		}
	},

	/**
	* Activates the initial view
	*
	* @private
	*/
	initFirstView: function () {
		var name, view,
			i = 0;

		if (this.views.length === 0) return;

		// find the first declared defaultView
		while ((view = this.views[i++]) && !name) {
			if (view.defaultView) {
				name = view.name;
			}
		}

		name = name || this.views[0].name;
		if (this.generated) {
			this.activate(name);
		} else {
			view = this.getView(name);
			this.activateImmediate(view);
		}
	},

	/**
	* Adds the list of components as views
	*
	* @param  {Object[]|module:enyo/Control~Control[]} components List of components
	* @param  {module:enyo/Control~Control|null} [owner] Owner of components
	*
	* @private
	*/
	importViewConfig: function (components, owner, isManager) {
		var c,
			i = 0;

		while (components && (c = components[i++])) {
			this.addView(c, owner, isManager);
		}
	},

	/**
	* Adds a new view to the view set
	*
	* @param {Object|module:enyo/Control~Control} view View config or instance
	* @param {module:enyo/Control~Control|null} [owner] Optional owner of view. Defaults to this.
	*
	* @private
	*/
	addView: function (view, owner, isManager) {
		var index,
			isControl = view instanceof Control,
			_view = isControl ? view : utils.clone(view),
			name = _view.name = _view.name || 'view' + (++viewCount);

		owner = _view.owner || owner || this;
		if (isControl) {
			_view.set('owner', owner);
			isManager = _view instanceof ViewMgr;
		} else {
			_view.owner = owner;
		}

		if (isManager) {
			// setting directly because the change handler is called manually during create
			_view.manager = this;
			this.viewManagers[name] = _view;
		} else {
			index = this.views.push(_view),
			this.viewNames[name] = index - 1;
		}
	},

	/**
	* Returns the index of the provided view. For fixed ViewManagers, this reflects the view's ordered
	* position. For floating ViewManagers, this reflects the last occurence of the view in the stack. If
	* the view isn't found, -1 is returned.
	*
	* @param  {module:enyo/Control~Control} view
	* @return {Number}      Index of `view`
	* @public
	*/
	indexOf: function (view) {
		var name = view && view.name;
		if (!name) return -1;

		return this.floating ? this.stack.lastIndexOf(name) : this.views.indexOf(view);
	},

	/**
	* Returns the currently active view
	*
	* @return {module:enyo/Control~Control}
	* @public
	*/
	getActive: function () {
		return this.active;
	},

	/**
	* Retrieves and creates, if necessary, a view or view manager by name
	*
	* @param {String} viewName Name of the view or view manager
	* @return {module:enyo/Control~Control} View
	* @public
	*/
	getView: function (viewName) {
		var view = this.viewManagers[viewName],
			index = this.viewNames[viewName];

		// if it's a manager
		if (view) {
			// but not created, create it
			if (!(view instanceof ViewMgr)) {
				view = this.viewManagers[viewName] = this.createComponent(view);
			}
		}
		// otherwise, it's probably a view
		else {
			view = this.views[index];
			// but it might need to be created too
			if (view && !(view instanceof Control)) {
				view = this.views[index] = this.createComponent(view);
				view.addClass('enyo-view');
			}
		}

		return view;
	},

	/**
	* Navigates to the next view based on order of definition or creation
	*
	* @param {Object} [opts] Optional parameters to configure the activation
	* @return {module:enyo/Control~Control} Activated view
	* @public
	*/
	next: function (opts) {
		var index = this.views.indexOf(this.active) + 1,
			view = this.views[index];
		if (view) {
			this.direction = 1;
			return this.activate(view.name, opts);
		}
	},

	/**
	* Navigates to the previous view based on order of definition or creation
	*
	* @param {Object} [opts] Optional parameters to configure the activation
	* @return {module:enyo/Control~Control} Activated view
	* @public
	*/
	previous: function (opts) {
		var index = this.views.indexOf(this.active) - 1,
			view = this.views[index];
		if (view) {
			this.direction = -1;
			return this.activate(view.name, opts);
		}
	},

	/**
	* If this is a floating ViewManager, navigates back `count` views from the stack.
	*
	* @param {Number} [count] Number of views to pop off the stack. Defaults to 1.
	* @param {Object} [opts] Optional parameters to configure the deactivation
	* @return {module:enyo/Control~Control} Activated view
	* @public
	*/
	back: function (count, opts) {
		var name,
			depth = this.stack.length;
		if (this.floating && depth > 0) {
			if (this.dragging) {
				name = this.stack[0];
			} else {
				count = count > depth ? depth : count || 1;
				name = this.stack.splice(0, count).pop();
			}
			this.direction = -1;
			return this._activate(name, opts);
		}
	},

	/**
	* Determines if the ViewManager can be dragged in the provided direction
	*
	* @param {Number} direction -1 or 1 indicating the direction of the drag
	* @param {String} [mode] When provided, requires `draggable` be `true` or the provided value
	* @private
	*/
	canDrag: function (direction, mode) {
		var index,
			check = mode ? this.draggable === true || this.draggable == mode : this.draggable;
		if (check) {
			if (this.isDimissable() && direction == -1) {
				return true;
			}
			else if (!this.floating) {
				index = this.views.indexOf(this.active);
				return	(index > 0 && direction == -1) ||
						(index < this.views.length - 1 && direction == 1);
			}
		}

		return false;
	},

	/**
	* @private
	*/
	determineDirection: function (view) {
		var isIndex, wasIndex;

		// for a floating VM, the default direction is always forward
		if (this.floating) {
			this.direction = 1;
		}
		// fixed VMs direction is based on each view's ordered position
		else {
			isIndex = this.indexOf(view);
			wasIndex = this.indexOf(this.active);
			this.direction = wasIndex < isIndex ? 1 : -1;
		}
	},

	/**
	* Indicates if the view is dismissable via dragging
	*
	* @return {Boolean}
	* @public
	*/
	isDimissable: function () {
		return this.dismissable === true || (this.dismissable == 'auto' && this.floating);
	},

	/**
	* Dismisses a view manager. If this is a root (manager-less) view manager, it cannot be
	* dismissed.
	*
	* @param {Object} [opts] Optional parameters to configure the deactivation
	* @public
	*/
	dismiss: function (opts) {
		if (this.manager) {
			this.direction = -1;
			this.set('activationOptions', opts);
			this.set('dismissed', true);
			this.emit('dismiss', {dragging: false});
			this.set('active', null);
			this.stack = [];
		}
	},

	/**
	* When any view event (activate, activated, deactivate, deactivated) fires, notify the view of
	* its change of state by calling a method matching the event (e.g. activate()), if it exists.
	*
	* @private
	*/
	notifyViews: function (sender, name, event) {
		var viewEvent = name == 'activate' || name == 'activated'
					|| name == 'deactivate' || name == 'deactivated';

		// Any event for a view will have an event payload with a view property indicating the view
		// that is changing.
		if (event && event.view && viewEvent && utils.isFunction(event.view[name])) {
			event.view[name](event);
		}
	},

	/**
	* @private
	*/
	emitViewEvent: function (name, view) {
		this.emit(name, {
			view: view,
			dragging: this.dragging,
			direction: this.direction
		});
	},

	/**
	* @private
	*/
	managerEvent: function (viewManager, event, view) {
		if (event == 'dismissed') this.managerDismissed(viewManager);
		this.emit('manager-' + event, {
			manager: viewManager
		});
	},

	/**
	* Handles dismissal of child view managers
	*
	* @private
	*/
	managerDismissed: function (viewManager) {
		this.teardownView(viewManager);
	},

	/**
	* Activates a new view.
	*
	* For floating ViewManagers, the view will be added to the stack and can be removed by `back()`.
	*
	* @param {String} viewName Name of the view to activate
	* @param {Object} [opts] Optional parameters to configure the activation
	* @public
	*/
	activate: function (viewName, opts) {
		var replace = !!(opts && opts.replace),
			view = this._activate(viewName, opts);
		if (!replace && view && !this.isManager(view) && this.active && this.floating) {
			this.stack.unshift(this.active.name);
		}

		return view;
	},

	/**
	* Activates a view
	*
	* @private
	*/
	_activate: function (viewName, opts) {
		var replace = !!(this.activationOptions && this.activationOptions.replace),
			view = this.getView(viewName);
		if (view) {
			if (!this._toBeActivated) {
				rAF(function () {
					this.activateImmediate(this._toBeActivated, opts);
					this._toBeActivated = null;
				}.bind(this));
			}
			else if (!replace && this.floating && !this.isManager(view)) {
				this.stack.unshift(this._toBeActivated.name);
			}
			this.set('activationOptions', opts);
			this._toBeActivated = view;
		}
		return view;
	},

	/**
	* @private
	*/
	activateImmediate: function (view, opts) {
		// render the activated view if not already
		if (this.generated && !view.generated) {
			view.set('canGenerate', true);
			view.render();
		}
		if (this.isManager(view)) {
			view.emit('manage');
		}
		else {
			if (!this.direction) this.determineDirection(view);
			this.emitViewEvent('activate', view);
			if (!this.dragging) this.set('active', view);
		}
	},

	/**
	* @private
	*/
	deactivate: function (viewName) {
		var view = this.getView(viewName);
		if (view) rAF(this.deactivateImmediate.bind(this, view));
		return view;
	},

	/**
	* @private
	*/
	deactivateImmediate: function (view) {
		this.teardownView(view);

		if (!this.isManager(view)) this.emitViewEvent('deactivated', view);
		if (!this.dragging && this.dismissed) this.emit('dismissed');
	},

	/**
	* Tears down a view or ViewManager if not flagged `persistent`
	*
	* @private
	*/
	teardownView: function (view) {
		if (view.node && !view.persistent) {
			if (!this.releaseDraggedView) {
				view.node.remove();
				view.node = null;
			}
			view.set('canGenerate', false);
			view.teardownRender(true);
		}
	},

	/**
	* @private
	*/
	isManager: function (view) {
		return view && !!this.viewManagers[view.name];
	},

	// Layout

	/**
	* Handles the 'complete' event from its layout indicating a view has completed its layout
	* @private
	*/
	handleLayoutComplete: function (sender, name, event) {
		if (event.was) this.deactivateImmediate(event.was);
		if (event.is) this.emitViewEvent('activated', event.is);
		this.direction = 0;
	},

	// Flick

	/**
	* Flicks are handled by the drag system so here we only test if there was a valid flick and rely
	* on the ondragfinish handler to actually act on the flick as if it were a completed drag.
	*
	* @private
	*/
	handleFlick: function (sender, event) {
		var isHorizontal = this.orientation == 'horizontal',
			dx = event.xVelocity,
			dy = event.yVelocity,
			adx = Math.abs(dx),
			ady = Math.abs(dy),
			direction = 0;

		// Set direction iff the primary flick direction matches the orientation
		if (isHorizontal && adx > ady) {
			direction = dx < 0 ? 1 : -1;
		}
		else if (!this.isHorizontal && ady > adx) {
			direction = dy < 0 ? 1 : -1;
		}

		// If we have a direction, are flickable, and flickable in that direction, indicate it
		if (direction && this.canDrag(direction, 'flick')) {
			this.flicked = true;
			return true;
		}
	},

	// Draggable

	/**
	* Handles `ondown` events
	*
	* @private
	*/
	handleDown: function (sender, event) {
		event.configureHoldPulse({endHold: 'onMove'});
	},

	/**
	* Handles `ondragstart` events
	*
	* @private
	*/
	handleDragStart: function (sender, event) {
		if (!this.draggable || this.dismissed) return;
		this.set('dragging', 'start');
		this.direction = 0;
		this.dragView = null;
		this.dragBounds = this.getBounds();

		return true;
	},

	/**
	* Handles `ondrag` events
	*
	* @private
	*/
	handleDrag: function (sender, event) {
		if (this.validateDrag(event)) {
			// clean up on change of direction
			if (this.direction !== event.direction) {
				this.direction = event.direction;
				if (this.dragView === false) {
					this.dragView = null;
				} else {
					this.resetDragView();
				}
			}

			// dragView can be a View, `false`, or `null`. `null` indicates we need to (try to)
			// activate the becoming-active view. It should be null when a drag starts or when
			// there's a change of direction. `false` indicates that we've tried to activate a view
			// but there isn't one in that direction.
			if (this.dragView === null) {
				if (this.direction == 1) {
					this.dragView = this.next();
				} else if (this.floating) {
					this.dragView = this.back();
					if (!this.dragView) this.emit('dismiss', {dragging: true});
				} else {
					this.dragView = this.previous();
				}
				this.dragView = this.dragView || false;
			}
			this.emit('drag', event);

			return true;
		} else {
			// Reset the drag state when dragging in an invalid direction
			this.resetDragView();
			this.direction = 0;
		}
	},

	/**
	* Handles `ondragfinish` events
	*
	* @private
	*/
	handleDragFinish: function (sender, event) {
		if (this.releaseDraggedView) {
			this.releaseDraggedView();
			this.releaseDraggedView = null;
		}
		if (this.validateDrag(event)) {
			// if the view has been dragged far enough
			if (this.flicked || event.percentDelta * 100 > this.dragThreshold) {
				this.set('dragging', false);
				// normally, there will be a becoming-active view to activate
				if (this.dragView) {
					// dragging for floating views can only be a back action so shift it off the stack
					if (this.floating) this.stack.shift();
					// stack updates aren't necessary as we updated it above
					this.activateImmediate(this.dragView);
				}
				// unless it's a floating ViewManager that is being dismissed
				else if (this.isDimissable() && event.direction == -1) {
					this.dismiss();
				}
			}
			// otherwise the drag was small enough to be cancelled
			else {
				this.cancelDrag();
			}
			this.flicked = false;
			event.preventTap();

			this.dragView = null;
			return true;
		} else {
			this.set('dragging', false);
			this.dragView = null;
		}
	},

	/**
	* Deactivates drag view and resets `dragView`
	*
	* @private
	*/
	resetDragView: function () {
		if (this.dragView) {
			this.emitViewEvent('deactivate', this.dragView);
			this.deactivate(this.dragView.name);
			this.dragView = null;
		}
	},

	/**
	* @protected
	*/
	cancelDrag: function () {
		var was = this.dragging;
		this.set('dragging', false);
		// only emit cancelDrag if a valid drag was encountered (=== true and != 'start')
		if (was === true) {
			// Since we're restoring the active view, the navigation direction is the opposite of the
			// drag direction.
			this.direction = -this.direction;
			this.emit('cancelDrag');
		}
	},

	/**
	* Validates that the drag event should be processed
	*
	* @private
	*/
	validateDrag: function (event) {
		var dragging = false,
			draggable = this.dragging && this.draggable && !this.dismissed;

		if (draggable) {
			this.decorateDragEvent(event);
			dragging =
				// check direction against orientation to ignore drags that don't apply to this. the
				// check should only be necessary for the first drag event so it's further guarded
				// by the special 'start' value of dragging.
				!(this.dragging == 'start' && !event[this.orientation]) &&

				// Intentionally ignoring draggable mode here so dragView will reference the
				// becoming-active view even if we are only supporting flick and not drag
				this.canDrag(event.direction);

			this.set('dragging', dragging);
		}

		return draggable && dragging;
	},

	/**
	* Calculates and adds a few additional properties to the event to aid in logic in ViewManager
	* and ViewLayout
	*
	* @private
	*/
	decorateDragEvent: function (event) {
		var isHorizontal = this.orientation == 'horizontal',
			size = isHorizontal ? this.dragBounds.width : this.dragBounds.height,
			delta = isHorizontal ? event.dx : event.dy;

		// 'natural' touch causes us to invert the physical change
		event.direction = delta < 0 ? 1 : -1;

		// if we're only flickable, we won't set the deltas to suppress the views moving until a
		// flick is encountered.
		if (this.canDrag(event.direction, 'drag')) {
			event.delta = delta;
			event.percentDelta = 1 - (size - Math.abs(event.delta)) / size;
		} else {
			event.delta = 0;
			event.percentDelta = 0;
		}
	}
});

module.exports = ViewMgr;

/**
* The {@link module:enyo/ViewManager~ScrimSupport} mixin
*
* @private
*/
module.exports.ScrimSupport = ScrimSupport;


text:
package main

import (
	"io/ioutil"
	"log"
	"os"
	"path"
	"path/filepath"
)

func main() {
	parseFlags()
	execute(conf.template, load(conf.data, conf.selector), makePrefix(conf.template))
}

func execute(name string, data interface{}, prefix []string) {
	absName, err := filepath.Abs(name)
	if err != nil {
		log.Fatal(err)
	}

	relName := getRelName(absName, prefix)
	log.Printf("executing %q", relName)

	fi, err := os.Stat(absName)
	if err != nil {
		log.Fatal(err)
	}

	newName := executeString(absName, data)
	if newName == absName {
		log.Fatalf("instance name is the same as template name %q", newName)
	}

	if fi.IsDir() {
		log.Printf("creating directory %q -> %q", relName, getRelName(newName, prefix))
		executeDir(newName)

		lst, err := ioutil.ReadDir(absName)
		if err != nil {
			log.Fatal(err)
		}

		for _, item := range lst {
			execute(path.Join(absName, item.Name()), data, prefix)
		}
	} else {
		log.Printf("creating file %q -> %q", relName, getRelName(newName, prefix))
		executeFile(newName, absName, data)
	}
}