public string FlagData(Flag flag)
		{
			string data = "";
			if (FlagUsed(flag))
				data = (string)flagUsed[flag];
			return data;
		}

        public void TestCustomFlag2()
        {
            var flags = new Flag<TESTENUM>(TESTENUM._1, TESTENUM._3);

            Assert.AreEqual(false, flags[TESTENUM._2]);
            Assert.AreEqual(true, flags[TESTENUM._3]);
        }

 public SingleBarrierOption(Flag flag, SingleBarrierFlag barrierFlag, double s, double x, double k, double h, double r, double b, double t, double sigma)
     : base(flag, s, x, r, b, t, sigma)
 {
     this.h = h;
     this.k = k;
     this.barrierFlag = barrierFlag;
 }

 // FLAGS
 // clearing: Removing rubble and preparing to build. Lots must be cleared before building.
 void AddFlag(string flag, int duration)
 {
     Flag f = new Flag ();
     f.name = flag;
     f.duration = duration;
     flags.Add (f);
 }

 public Account()
 {
     Competnces = new Flag<COMPETENCE>();
     Guid = Guid.NewGuid();
     Name = Id.ToString();
     Password = Id.ToString();
 }

 /// <summary>
 /// Creates a new instance of GapOption
 /// </summary>
 /// <param name="flag">Call/Put flag</param>
 /// <param name="s">Asset price</param>
 /// <param name="x">Strike price</param>
 /// <param name="x">Strike price 2</param>
 /// <param name="r">Risk-free interest rate</param>
 /// <param name="b">Yield</param>
 /// <param name="t">Time to expiry in years</param>
 /// <param name="sigma">Asset volatility</param>
 public GapOption(Flag flag, double s, double x1, double x2, double r, double b, double t, double sigma)
     : base(flag, s, x1, r, b, t, sigma)
 {
     this.x2 = x2;
     d1 = (Math.Log(s / x) + (r - b + (0.5 * Math.Pow(sigma, 2))) * t) / (sigma * Math.Sqrt(t));
     d2 = d1 - sigma * Math.Sqrt(t);
 }

 public YNode(int depth,object key,object o,int rf,Flag flags) {
     Depth=depth;
     Key=key;
     O=o;
     Ref=rf;
     Flags=flags;
 }

 public void executeAnimation(Flag.Face.FlagFaceState f)
 {
     switch (f) {
         case Flag.Face.FlagFaceState.STATE_BLINK:
             animator.SetTrigger("blink");
             break;
         case Flag.Face.FlagFaceState.STATE_ATTACK:
             animator.SetTrigger("attack");
             break;
         case Flag.Face.FlagFaceState.STATE_CHARGE:
             animator.SetTrigger("charge");
             break;
         case Flag.Face.FlagFaceState.STATE_DANGER:
             animator.SetTrigger("danger");
             break;
         case Flag.Face.FlagFaceState.STATE_HIT:
             animator.SetTrigger("hit");
             break;
         case Flag.Face.FlagFaceState.STATE_TELL:
             animator.SetTrigger("tell");
             break;
         default:
             break;
     }
 }

        private string[,] getRssData(string channel)
        {
            Console.WriteLine("LOADING FEED... Please wait.");
            XmlNodeList items;
            try
            {
                WebRequest request = WebRequest.Create(channel);
                WebResponse responce = request.GetResponse();
                Stream rssStream = responce.GetResponseStream();
                XmlDocument rssDoc = new XmlDocument();
                rssDoc.Load(rssStream);
                items = rssDoc.SelectNodes("rss/channel/item");
            }
            catch (UriFormatException)
            {
                Console.Clear();

                    Console.WriteLine("\n");
                    Console.WriteLine($"Error: {channel} doesn't seem to be a valid feed URL. Exiting.");
                    Thread.Sleep(1500);

                Console.Clear();
                Flag flag = new Flag("-help");
                flag.Do();
                return null;
            }
            catch (Exception ex)
            {
                Console.Clear();

                    Console.WriteLine("\n");
                    Console.WriteLine($"Cannot load feed. Why? {ex.Message}");
                    Thread.Sleep(1500);

                Console.Clear();
                Flag flag = new Flag("-help");
                flag.Do();
                return null;
            }

            string[,] tempRssData = new string[items.Count, 3];
            for (int i = 0; i < items.Count; i++)
            {
                XmlNode rssNode;

                rssNode = items.Item(i).SelectSingleNode("title");

                if (rssNode != null) tempRssData[i, 0] = rssNode.InnerText;
                else tempRssData[i, 0] = "";

                rssNode = items.Item(i).SelectSingleNode("description");
                if (rssNode != null) tempRssData[i, 1] = rssNode.InnerText;
                else tempRssData[i, 1] = "";

                rssNode = items.Item(i).SelectSingleNode("link");
                if (rssNode != null) tempRssData[i, 2] = rssNode.InnerText;
                else tempRssData[i, 2] = "";
            }
            return tempRssData;
        }

	/// <summary>
	/// 异步调用函数并等待其完成 (有死锁风险)
	/// </summary>
	/// <param name="action">欲调用的函数</param>
	public static void RunUntilFinish(Action action, Flag cancelFlag=null)
	{
		if (IsMainThread())
			action();
		else
			RunUntilFinish(MakeCoroutineFromAction(action), cancelFlag);
	}

 private static short[] ReadCoordinates(BinaryReader input, int pointCount, Flag[] flags, Flag isByte, Flag signOrSame)
 {
     var xs = new short[pointCount];
     int x = 0;
     for (int i = 0; i < pointCount; i++)
     {
         int dx;
         if (flags[i].HasFlag(isByte))
         {
             var b = input.ReadByte();
             dx = flags[i].HasFlag(signOrSame) ? b : -b;
         }
         else
         {
             if (flags[i].HasFlag(signOrSame))
             {
                 dx = 0;
             }
             else
             {
                 dx = input.ReadInt16();
             }
         }
         x += dx;
         xs[i] = (short)x; // TODO: overflow?
     }
     return xs;
 }

        public String CreateFlagsXML(Flag[] flags, String personID)
        {
            // Create the xml document
            XmlDocument doc = new XmlDocument();// Create the XML Declaration, and append it to XML document
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "utf-8", null);
            doc.AppendChild(dec);// Create the root element
            XmlElement root = doc.CreateElement("UpdateFlags");
            doc.AppendChild(root);
            // Note that to set the text inside the element,
            // you use .InnerText instead of .Value (which will throw an exception).
            // You use SetAttribute to set attribute
            foreach (Domain.Flag curFlag in flags)
            {
                if (curFlag != null)
                {
                    XmlElement Flag = doc.CreateElement("Flag");
                    XmlElement FlagValue = doc.CreateElement("FlagValue");
                    XmlElement FlagNumber = doc.CreateElement("FlagNumber");
                    XmlElement Person_ID = doc.CreateElement("PersonID");
                    FlagValue.InnerText = curFlag.FlagValue;
                    FlagNumber.InnerText = curFlag.FlagNumber.ToString();
                    Person_ID.InnerText = personID;
                    Flag.AppendChild(FlagValue);
                    Flag.AppendChild(FlagNumber);
                    Flag.AppendChild(Person_ID);
                    root.AppendChild(Flag);
                }
            }

            string xmlOutput = doc.OuterXml;
            return xmlOutput;
        }

 public void Unpack()
 {
     CommandId          = (UInt16)(Buffer[1] | (((UInt16)Buffer[2]) << 8));
     Flags              = (Flag)Buffer[3];
     PacketInterval     = Buffer[4];
     KeepAliveIntervalMs= (UInt16)(Buffer[5] | (((UInt16)Buffer[6]) << 8));
 }

        /**
         * Adds a flag
         */
        public static Flag AddFlag(string name, bool state = false)
        {
            Flag newFlag = new Flag(name, state);

            GetInstance().flags.Add(newFlag);

            return newFlag;
        }

	public FlaggedUsersDetails(FlaggedUsersViewModel viewModel, Flag flag)
    {
      InitializeComponent();
	  Icon = "badge.png";
		viewModel.Flag = flag;
		Title = flag.AlertLevel.ToString();
	  BindingContext = this.viewModel = viewModel;
    }

 protected HotRodOperation(Codec codec, Flag[] flags, byte[] cacheName, int topologyId)
 {
     this.flags = flags;
     this.cacheName = cacheName;
     this.topologyId = topologyId;
     this.codec = codec;
     logger = LogManager.GetLogger("Hot Rod Operation");
 }

 //private readonly IdCardClient idCardClient;
 public AddFlagsPresenter(Flag[] flags, String personID)
 {
     String xml = CreateFlagsXML(flags, personID);
     //MessageBoxResult result = MessageBox.Show("personID: " + personID);
     System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
     Byte[] bytes = System.Text.Encoding.UTF8.GetBytes(xml);
     IdCardClient idCardClient = new IdCardClient();
     idCardClient.UpdateFlags(bytes, STAGE_HOST, new WSSessionAuthenticationProvider());
 }

 public DoubleBarrierOption(Flag flag, DoubleBarrierFlag barrierFlag, double s, double x, double l, double u, double r, double b, double t, double sigma, double delta1 = 0, double delta2 = 0)
     : base(flag, s, x, r, b, t, sigma)
 {
     this.l = l;
     this.u = u;
     this.delta1 = delta1;
     this.delta2 = delta2;
     this.barrierFlag = barrierFlag;
 }

 public SensorConfig()
 {
     this.CommandId = 0;
     this.Flags = 0;
     this.PacketInterval = 0;
     this.KeepAliveIntervalMs = 0;
     Array.Clear(Buffer, 0, 0);
     Buffer[0] = 2;
 }

		protected void FullExpr( Flag flags )
		{
			var mark = Cgen.ExprStart();
			if( ((flags & Flag.Noexpr) == 0) || (!Noexpr( flags )) )
			{
				Expression( flags & (~Flag.Noexpr) );
			}
			Cgen.ExprEnd( mark );
		}//FullExpr