private JObject getRequestJSONObject(List<Placement> placements, Flags flags = null, string medium = null, string frame = null, string title = null, bool useIframe = false)
        {
            JObject jsonObject = new JObject();

            if (placements != null && placements.Count > 0) {
                JArray placementsJSONArray = new JArray();
                foreach (var placement in placements) {
                    placementsJSONArray.Add(JObject.Parse(base.jsonSerializer.Serialize(placement)));
                }
                jsonObject.Add("placements", placementsJSONArray);
            }

            if (flags != null) {
                jsonObject.Add("flags", JObject.Parse(base.jsonSerializer.Serialize(flags)));
            }

            if (medium != null) {
                jsonObject.Add("medium", new JValue(medium));
            }

            if (frame != null) {
                jsonObject.Add("frame", new JValue(frame));
            }

            if (title != null) {
                jsonObject.Add("title", new JValue(title));
            }

            jsonObject.Add("useiframe", new JValue(useIframe));

            return jsonObject;
        }

 public MapCallInfo(Type targetType, Type[] genericTypes, Flags bindingFlags, MemberTypes memberTypes, string name, Type[] parameterTypes, MemberInfo memberInfo, bool isReadOperation, Type sourceType, MemberTypes sourceMemberTypes, MemberTypes targetMemberTypes, string[] names) : base(targetType, genericTypes, bindingFlags, memberTypes, name, parameterTypes, memberInfo, isReadOperation)
 {
     SourceType = sourceType;
     SourceMemberTypes = sourceMemberTypes;
     TargetMemberTypes = targetMemberTypes;
     Names = names;
 }

 public void SetFlag(Flags flag, bool b)
 {
     if (b)
         StatusRegister |= (byte)flag;
     else
         StatusRegister &= (byte)~flag;
 }

 /// <summary>
 /// Creates a delegate which can get the value of an indexer matching <paramref name="bindingFlags"/>.
 /// </summary>
 /// <param name="type">The type which the indexer belongs to.</param>
 /// <param name="bindingFlags">The binding flags used to lookup the indexer.</param>
 /// <param name="parameterTypes">The types of the indexer parameters (must be in the right order).</param>
 /// <returns>The delegate which can get the value of an indexer.</returns>
 public static MethodInvoker DelegateForGetIndexer( this Type type, Flags bindingFlags,
                                                    params Type[] parameterTypes )
 {
     return (MethodInvoker)
         new MethodInvocationEmitter( type, bindingFlags, Constants.IndexerGetterName, parameterTypes ).
             GetDelegate();
 }

        public static void SendMail(Flags flag)
        {
            Flags result = 0x00;
            // Define action-lookup
            int intero = 1;
            //string stringa = "email";

            var actionsByFlag = new Dictionary<Flags, Func<int, Flags>>
            {
                { Flags.Notify, Notify },
                { Flags.Email, Email }
            };

            // Find applicable actions
            var actions = actionsByFlag.Where(kvp => (flag & kvp.Key) == kvp.Key)
                                       .Select(kvp => kvp.Value);

            //Execute applicable actions
            foreach (var action in actions)
                result = result | action(intero);

            Console.WriteLine("Risultato");
            Console.WriteLine(result);
            Console.ReadLine();
        }

 void Awake()
 {
     GameObject c = GameObject.FindGameObjectWithTag ("GameController");
     flags = c.GetComponent<Flags>();
     transition = GameObject.FindGameObjectWithTag("Fader").GetComponent<SceneTransition>();
     flags.AddCutsceneFlag(cutsceneDialogue.name);
 }

        public void Resolve_Nosynonyms_ArgumentNotFound_ReturnsNull()
        {
            var flags = new Flags();

            var result = flags.Resolve("argument");

            Assert.IsNull(result);
        }

        public void Resolve_Twosynonyms_ResolveSecondsynonym_ReturnsArgument()
        {
            var flags = new Flags();
            flags.Add("argument", "-a", "--a");

            var result = flags.Resolve("--a");

            Assert.That(result, Is.EqualTo("argument"));
        }

        public void Resolve_Nosynonyms_ArgumentFound_ReturnsArgument()
        {
            var flags = new Flags();
            flags.Add("argument");

            var result = flags.Resolve("argument");

            Assert.That(result, Is.EqualTo("argument"));
        }

 public static void InitializeResolver(Flags f)
 {
     UrlResolver.HrefResolver =
         new Lazy<IPathResolver>(
             () =>
             new ContentResolver
             {
                 ContentDir = f.WebAppRoot
             });
 }

 public Line(float x, float y, float x2, float y2, float a, float a2, Flags flags, int priority)
     : base(flags, priority << 16)
 {
     X = x;
     Y = y;
     X2 = x2;
     Y2 = y2;
     _a = a;
     _a2 = a2;
 }

		internal VisualStudioHelper()
		{
			ScratchFiles = new List<ScratchFile>();
			Projects = new List<ProjectFacade>();
			Solution = null;
			Log = new List<LogEntry>();
			HasConfig = false;
			Flags = new Flags();
			
	}

 public void SetFlag(Flags mask, bool value)
 {
     if (value)
     {
         this.flags |= mask;
     }
     else
     {
         this.flags &= ~mask;
     }
 }

 private static byte[] Read_CWav(Stream stream, Flags flags)
 {
     if (flags.SoundEffect)
     {
         using (var br = new BinaryReader(stream, Encoding.ASCII, true))
         {
             stream.Position = 0xBC;
             var len = br.ReadUInt32();
             var offset = br.ReadUInt32();
             stream.Position = offset;
             return br.ReadBytes((int) len);
         }
     }
     return new byte[0];
 }

        public static void Test()
        {
            int result;
            //3
            result = new Flags().solution(new int[] { 1, 5, 3, 4, 3, 4, 1, 2, 3, 4, 6, 2 });

            //2
            result = new Flags().solution(new int[] { 0, 1, 0, 1, 0, 1, 0 });

            //2
            result = new Flags().solution(new int[] { 0, 1, 0, 0, 1, 0, 1, 0 });

            //3
            result = new Flags().solution(new int[] { 0, 1, 0, 0, 1, 0, 1, 0, 1, 0 });
        }

        public static int Main(string[] args)
        {
            var flags = new Flags(args);

            if (flags.HelpRequested)
            {
                flags.ShowUsage(Console.Out);
                return 0;
            }

            ConfigureLogging(flags.Verbose);

            using (var program = new Program(flags.WorkingDirectory, flags.ErrorWriter))
            {
                return program.Run() == 0 ? 0 : -1;
            }
        }

        public void MessageReceived(LCM.LCM.LCM lcm, string channel, LCM.LCM.LCMDataInputStream dins)
        {
            Console.WriteLine("RECV: " + channel);

            if (channel == "MaestroDriver/Flags")
            {
                Flags msg = new Flags(dins);
                Console.WriteLine("length1=" + msg.goals.Length);
                Console.WriteLine("length2=" + msg.goals.LongLength);
                for(int goal = 0; goal< 4; goal++)
                {
                    for(int box = 0; box < 5; box++)
                    {
                        Console.WriteLine ("element goal=" + goal + ",\t box=" + box + ", value=" + msg.goals[goal,box]);
                        this.field.Goals[goal].setFlagPosition(box, msg.goals[goal, box]);
                    }
                }
            }
        }

 public MapEmitter(Type sourceType, Type targetType, MemberTypes sourceMemberTypes, MemberTypes targetMemberTypes,
                    Flags bindingFlags, params string[] names)
     : base(new MapCallInfo(targetType, null,
         // Auto-apply IgnoreCase if we're mapping from one membertype to another
         Flags.SetIf(bindingFlags, Flags.IgnoreCase, (sourceMemberTypes & targetMemberTypes) != sourceMemberTypes),
         MemberTypes.Custom,
         "Mammatus.Library.Reflection_Map",
         Type.EmptyTypes,
         null,
         false,
         sourceType,
         sourceMemberTypes,
         targetMemberTypes,
         names))
 {
     this.sourceType = sourceType;
     this.sourceMemberTypes = sourceMemberTypes;
     this.targetMemberTypes = targetMemberTypes;
     this.names = names;
 }

        /// <summary>
        /// Gets the member identified by <paramref name="name"/> on the given <paramref name="type"/>. Use
        /// the <paramref name="bindingFlags"/> parameter to define the scope of the search.
        /// </summary>
        /// <returns>A single MemberInfo instance of the first found match or null if no match was found.</returns>
        public static MemberInfo Member(this Type type, string name, Flags bindingFlags)
        {
            // we need to check all members to do partial name matches
            if (bindingFlags.IsAnySet(Flags.PartialNameMatch | Flags.TrimExplicitlyImplemented))
            {
                return type.Members(MemberTypes.All, bindingFlags, name).FirstOrDefault();
            }

            IList<MemberInfo> result = type.GetMember(name, bindingFlags);
            bool hasSpecialFlags = bindingFlags.IsAnySet(Flags.ExcludeBackingMembers | Flags.ExcludeExplicitlyImplemented | Flags.ExcludeHiddenMembers);
            result = hasSpecialFlags && result.Count > 0 ? result.Filter(bindingFlags) : result;
            bool found = result.Count > 0;

            if (!found && bindingFlags.IsNotSet(Flags.DeclaredOnly))
            {
                if (type.BaseType != typeof(object) && type.BaseType != null)
                {
                    return type.BaseType.Member(name, bindingFlags);
                }
            }
            return found ? result[0] : null;
        }

	public void SetFlag(Flags mask, bool value) { if (value) flags |= mask;	else flags &= ~mask; }