/// <summary>
        /// Customize this child
        /// </summary>
        public IsosTri90Tess()
        {
            InitializeComponent();
            double size = 40d;
            double temp = Math.Tan(Math.PI / 4d) * (size / 2);
            Pattern pat = new Pattern(size, temp * 2d, 0);
            List<DoublePoint> tri1 = new List<DoublePoint>();
            List<DoublePoint> tri2 = new List<DoublePoint>();
            List<DoublePoint> tri3 = new List<DoublePoint>();
            List<DoublePoint> tri4 = new List<DoublePoint>();
            addStartZone(new Point(0, 0), new Point((int)size, 0));
            setShapeHeight(temp);

            tri1.Add(new DoublePoint(0, 0));
            tri1.Add(new DoublePoint(size / 2, temp));
            tri1.Add(new DoublePoint(0, temp*2));

            tri2.Add(new DoublePoint(0, 0));
            tri2.Add(new DoublePoint(size, 0));
            tri2.Add(new DoublePoint(size / 2, temp));

            tri3.Add(new DoublePoint(size, temp * 2));
            tri3.Add(new DoublePoint(0, temp * 2));
            tri3.Add(new DoublePoint(size / 2, temp));

            tri4.Add(new DoublePoint(size, temp * 2));
            tri4.Add(new DoublePoint(size, 0));
            tri4.Add(new DoublePoint(size / 2, temp));

            pat.addPattern(tri1);
            pat.addPattern(tri2);
            pat.addPattern(tri3);
            pat.addPattern(tri4);
            setPattern(pat);
        }

        /// <summary>
        /// Customize this child
        /// </summary>
        public RectTess(double ratio)
        {
            InitializeComponent();

            double patBase = 30;
            // ratioOver1 is used to scale down the rectangle
            double ratioOver1 = ratio - 1;
            if (ratioOver1 > 0)
            {
                // If the ratioOver1 is over 1, the scale down will be much to small, so we will make 1 the max.
                if (ratioOver1 > 1d)
                    ratioOver1 = 1d;
                patBase /= ratioOver1 + 1;
            }
            double heightRatio = ratio;
            double patHeight = patBase * heightRatio;
            double patWidth = patBase;
            addStartZone(new Point(0, 0), new Point((int)patWidth, 0));
            setShapeHeight(patHeight);

            Pattern pat = new Pattern(patWidth, patHeight, 0d);
            List<DoublePoint> tri1 = new List<DoublePoint>();

            tri1.Add(new DoublePoint(0, 0));
            tri1.Add(new DoublePoint(0, patHeight));
            tri1.Add(new DoublePoint(patWidth, patHeight));
            tri1.Add(new DoublePoint(patWidth, 0));

            pat.addPattern(tri1);
            setPattern(pat);
        }

        /// <summary>
        ///   Creates a new instance of the <see cref="SchematronValidationEventArgs"/>.
        /// </summary>
        /// <param name="schematron">The <see cref="SchematronDocument"/> that detected the event.</param>
        /// <param name="queryEngine">The <see cref="IQueryLanguage"/> that detected the event.</param>
        /// <param name="pattern">The active <see cref="Pattern"/>.</param>
        /// <param name="rule">The <see cref="Sepia.Schematron.Rule"/> that caused the event to be raised.</param>
        /// <param name="assertion">The <see cref="Sepia.Schematron.Assertion"/> that caused the event to be raised.</param>
        /// <param name="context">An <see cref="object"/> that provides the context for the <paramref name="rule"/> and <paramref name="assertion"/>.</param>
        /// <param name="instance">An <see cref="XPathNavigator"/> to the document node that cause the event to be raised.</param>
        public SchematronValidationEventArgs(SchematronDocument schematron, IQueryLanguage queryEngine, Pattern pattern, Rule rule, Assertion assertion, object context, XPathNavigator instance)
        {
            this.schematron = schematron;
             this.queryEngine = queryEngine;
             this.pattern = pattern;
             this.rule = rule;
             this.assertion = assertion;
             this.instance = instance.Clone();

             if (assertion == null)
             {
            message = "A schematron validation event occured.";
             }
             else
             {
            message = assertion.Message.ToString(instance, context);
             }

             List<string> diagnostics = new List<string>();
             if (assertion != null && !string.IsNullOrEmpty(assertion.Diagnostics))
             {
            foreach (string id in assertion.Diagnostics.Split(' '))
            {
               Diagnostic diagnostic = schematron.Diagnostics[id];
               diagnostics.Add(diagnostic.Message.ToString(instance, context));
            }
             }
             this.diagnostics = diagnostics.ToArray();
        }

 public MatchResult(Pattern pattern, int x, int y, E_BlockType type)
 {
     this.pattern = pattern;
     this.x = x;
     this.y = y;
     this.type = type;
 }

 public static void PlayTact(Note root, Pattern pattern, OutputDevice outputDevice)
 {
     PlayAccord(root, pattern, Direction.Down, outputDevice);
     Thread.Sleep(400);
     PlayAccord(root, pattern, Direction.Down, outputDevice);
     Thread.Sleep(150);
     PlayAccord(root, pattern, Direction.Up, outputDevice);
     Thread.Sleep(400);
     PlayAccord(root, pattern, Direction.Up, outputDevice);
     Thread.Sleep(200);
     PlayAccord(root, pattern, Direction.Down, outputDevice);
     Thread.Sleep(150);
     PlayAccord(root, pattern, Direction.Up, outputDevice);
     Thread.Sleep(200);
     PlayAccord(root, pattern, Direction.Down, outputDevice);
     Thread.Sleep(400);
     PlayAccord(root, pattern, Direction.Down, outputDevice);
     Thread.Sleep(150);
     PlayAccord(root, pattern, Direction.Up, outputDevice);
     Thread.Sleep(400);
     PlayAccord(root, pattern, Direction.Up, outputDevice);
     Thread.Sleep(200);
     PlayAccord(root, pattern, Direction.Down, outputDevice);
     //Thread.Sleep(150);
     //PlayAccord(root, pattern, Direction.Up, outputDevice);
     Thread.Sleep(400);
 }

    private void GeneratePattern()
    {
        Pattern pattern = new Pattern();

        int count = Random.Range(GameController.instance.minPatternSize_, GameController.instance.maxPatternSize_ + 1);

        var node = nodes_.Last;
        for (int index = Random.Range(0, nodes_.Count); index > 0; --index, node = node.Previous) ;

        node.Value.isActive = false;
        pattern.pattern.AddLast(node.Value);

        for (int i = 0; i < count; ++i) {
            LinkedList<PatternNode> adjacentNodes = node.Value.GetActiveAdjacentNodes();

            if (adjacentNodes.Count < 0) {
                break;
            }

            var adjacentNode = adjacentNodes.Last;
            for (int index = Random.Range(0, adjacentNodes.Count); index > 0; --index, adjacentNode = adjacentNode.Previous) ;

            pattern.pattern.AddLast(adjacentNode.Value);
            node = nodes_.Find(adjacentNode.Value);
            node.Value.isActive = false;
        }

        GameController.instance.RegisterPattern(pattern);
        for (node = nodes_.First; node != null; node.Value.isActive = true, node = node.Next) ;
    }

 /// <summary>
 /// This Method Performs Drag and Drop an element from scrolllist to Workfield by Sikuli4net
 /// </summary>
 /// <param name="scrollElement">Scroll Element class</param>
 public void DragAndDrop(ScrollElement scrollElement)
 {
     Pattern pattern_Drag = new Pattern(Configuration.PathToImgs()+scrollElement.GetImageDragPatern());
     Pattern pattern_Drop = new Pattern(Configuration.PathToImgs() + "wrk.png",0.5f);
     Screen scrn = new Screen();
     scrn.DragDrop(pattern_Drag,pattern_Drop);
 }

        public override void Init(ParsingContext context, ParseTreeNode parseNode)
        {
            base.Init(context, parseNode);

            foreach (var node in parseNode.ChildNodes)
            {
                if (node.AstNode is Pattern)
                {
                    Pattern = node.AstNode as Pattern;
                }
                else if (node.AstNode is AuxiliaryNode)
                {
                    var nodes = (node.AstNode as AuxiliaryNode).ChildNodes;
                    Conditions = nodes.OfType<Conditions>().FirstOrDefault();
                    Expression = nodes.OfType<Expression>().FirstOrDefault();
                }
            }

            foreach (var astNode in new AstNode[] { Pattern, Conditions, Expression })
            {
                if (astNode != null)
                {
                    astNode.Parent = this;
                }
            }

            AsString = "match";
        }

 public Captcha(int pattern, int leftOperand, int operatorValue, int rightOperand)
 {
     this.leftOperand = leftOperand;
     this.rightOperand = rightOperand;
     this.operatorValue = operatorValue;
     this.pattern = (Pattern)pattern;
 }

        public static Pattern ParseMatcher(string feature, bool applyToMembers)
        {
            Match m = Parser.Match(feature);
            if (!m.Success)
            {
                DLog.Warning(DContext.CompilerStart, "pattern parsing error :" + feature);
                return null;
            }

            Pattern match = new Pattern();
            if (m.Groups[1].Success) match.TypeMatcher = m.Groups[1].Value;
            if (m.Groups[2].Success) match.TypeInheritanceKeyword = m.Groups[2].Value;
            if (m.Groups[3].Success) match.TypeInheritanceName = m.Groups[3].Value;
            if (m.Groups[4].Success) match.MemberMatcher = m.Groups[4].Value;
            if (m.Groups[5].Success) match.MembersPublicOnly = true;
            if (m.Groups[6].Success) match.Attributes.Add(m.Groups[6].Value);
            if (m.Groups[7].Success)
                foreach (Capture cap in m.Groups[7].Captures)
                    match.Attributes.Add(cap.Value);

            match.ApplyToMembers = applyToMembers;

            if (match.TypeMatcher == null && match.MemberMatcher == null)
            {
                DLog.Warning(DContext.CompilerStart, "either type or member matcher should be specified: " + feature);
                return match;
            }
            return match;
        }

        public static void Main(string[] args)
        {
            string inputname = args[0];
            string outputname = args[1];

            string[] lines = File.ReadAllLines(inputname);

            int ncases = int.Parse(lines[0]);
            int nline = 0;
            IList<string> results = new List<string>();

            for (int k = 0; k < ncases; k++)
            {
                Console.WriteLine(string.Format("Solving Case #{0}", k + 1));
                nline++;
                string[] numbers = lines[nline].Split(' ');
                int height = int.Parse(numbers[0]);
                int width = int.Parse(numbers[1]);
                Pattern pattern = new Pattern(width, height);

                for (int j = 0; j < height; j++)
                {
                    nline++;
                    pattern.SetRow(j, lines[nline]);
                    Console.WriteLine(lines[nline]);
                }

                results.Add(string.Format("Case #{0}: {1}", k+1, pattern.HasSolution() ? "YES" : "NO"));
            }

            File.WriteAllLines(outputname, results.ToArray());
        }

 private static Pattern<Word, ShapeNode> CreateEnvironmentPattern(Pattern<Word, ShapeNode> env)
 {
     Pattern<Word, ShapeNode> pattern = null;
     if (!env.IsEmpty)
         pattern = new Pattern<Word, ShapeNode>(env.Children.DeepCloneExceptBoundaries());
     return pattern;
 }

        public SynthesisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative, Pattern<Word, ShapeNode> lhs,
			IEnumerable<RewriteSubrule> subrules)
            : base(lhs.IsEmpty)
        {
            Pattern.Acceptable = match => CheckTarget(match, lhs);

            if (lhs.IsEmpty)
            {
                Pattern.Children.Add(new Constraint<Word, ShapeNode>(FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
            }
            else
            {
                foreach (Constraint<Word, ShapeNode> constraint in lhs.Children.Cast<Constraint<Word, ShapeNode>>())
                {
                    var newConstraint = constraint.DeepClone();
                    if (isIterative)
                        newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
                    Pattern.Children.Add(newConstraint);
                }
            }
            Pattern.Freeze();

            int i = 0;
            foreach (RewriteSubrule subrule in subrules)
            {
                if (lhs.Children.Count == subrule.Rhs.Children.Count)
                    SubruleSpecs.Add(new FeatureSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, subrule, i));
                else if (lhs.Children.Count > subrule.Rhs.Children.Count)
                    SubruleSpecs.Add(new NarrowSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, lhs.Children.Count, subrule, i));
                else if (lhs.Children.Count == 0)
                    SubruleSpecs.Add(new EpenthesisSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, subrule, i));
                i++;
            }
        }

    public void Init(string s)
    {
        animation = GetComponent<VillagerAnimation>();
		animation.Init (s);

        skinMaterial = GetComponentInChildren<MeshRenderer>().material;
        origColor = skinMaterial.color;

        // music stuff
        musicToggle = GetComponent<ToggleSuspend>();
        musicPattern = GetComponent<Pattern>();
        SetMusicPattern();
        musicSample = GetComponent<Sampler>();
        SetMusicSample();

		keyboardPosition = transform.localPosition;

        textMesh = GetComponentInChildren<TextMesh>();

        letter = s;
        textMesh.text = s;

		currentState = State.Idle;
		timeSinceLastDanced = Time.time;
    }

 public static Pattern TwoColumns()
 {
     var pattern = new Pattern();
     pattern.WholeColumns.Add(-1);
     pattern.WholeColumns.Add(-2);
     return pattern;
 }

        public FeatureAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, Pattern<Word, ShapeNode> lhs, RewriteSubrule subrule)
            : base(false)
        {
            var rhsAntiFSs = new List<FeatureStruct>();
            foreach (Constraint<Word, ShapeNode> constraint in subrule.Rhs.Children.OfType<Constraint<Word, ShapeNode>>().Where(c => c.Type() == HCFeatureSystem.Segment))
                rhsAntiFSs.Add(constraint.FeatureStruct.AntiFeatureStruct());

            Pattern.Acceptable = match => IsUnapplicationNonvacuous(match, rhsAntiFSs);

            _analysisRhs = new Pattern<Word, ShapeNode>();
            int i = 0;
            foreach (Tuple<PatternNode<Word, ShapeNode>, PatternNode<Word, ShapeNode>> tuple in lhs.Children.Zip(subrule.Rhs.Children))
            {
                var lhsConstraint = (Constraint<Word, ShapeNode>) tuple.Item1;
                var rhsConstraint = (Constraint<Word, ShapeNode>) tuple.Item2;

                if (lhsConstraint.Type() == HCFeatureSystem.Segment && rhsConstraint.Type() == HCFeatureSystem.Segment)
                {
                    var targetConstraint = lhsConstraint.DeepClone();
                    targetConstraint.FeatureStruct.PriorityUnion(rhsConstraint.FeatureStruct);
                    targetConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
                    Pattern.Children.Add(new Group<Word, ShapeNode>("target" + i) {Children = {targetConstraint}});

                    FeatureStruct fs = rhsConstraint.FeatureStruct.AntiFeatureStruct();
                    fs.Subtract(lhsConstraint.FeatureStruct.AntiFeatureStruct());
                    fs.AddValue(HCFeatureSystem.Type, HCFeatureSystem.Segment);
                    _analysisRhs.Children.Add(new Constraint<Word, ShapeNode>(fs));

                    i++;
                }
            }
            Pattern.Freeze();

            SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
        }

        /// <summary>
        /// Create a new <seealso cref="PatternKeywordMarkerFilter"/>, that marks the current
        /// token as a keyword if the tokens term buffer matches the provided
        /// <seealso cref="Pattern"/> via the <seealso cref="KeywordAttribute"/>.
        /// </summary>
        /// <param name="in">
        ///          TokenStream to filter </param>
        /// <param name="pattern">
        ///          the pattern to apply to the incoming term buffer
        ///  </param>
        public PatternKeywordMarkerFilter(TokenStream @in, Pattern pattern)
            : base(@in)
        {
            termAtt = AddAttribute<ICharTermAttribute>();

            this.matcher = pattern.matcher("");
        }

        /// <summary>
        /// Customize this child
        /// </summary>
        public HexagonTess()
        {
            InitializeComponent();

            double xSmallSegment = 10d;
            double xLargeSegment = 20d;
            double ySegment = Math.Cos(Math.PI / 6) * 20d;
            double height = ySegment * 2;
            double width = 40d;

            addStartZone(new Point((int)xSmallSegment, 0), new Point((int)(xSmallSegment + xLargeSegment), 0));
            setShapeHeight(height);

            Pattern pat = new Pattern(60d, height, 0d);
            List<DoublePoint> shape1 = new List<DoublePoint>();
            List<DoublePoint> shape2 = new List<DoublePoint>();

            shape1.Add(new DoublePoint(xSmallSegment + xLargeSegment, 0));
            shape1.Add(new DoublePoint(xSmallSegment, 0));
            shape1.Add(new DoublePoint(0, ySegment));
            shape1.Add(new DoublePoint(xSmallSegment, height));
            shape1.Add(new DoublePoint(xSmallSegment + xLargeSegment, height));
            shape1.Add(new DoublePoint(width, ySegment));

            shape2.Add(new DoublePoint(xLargeSegment + xLargeSegment + xSmallSegment + xSmallSegment, ySegment));
            shape2.Add(new DoublePoint(xLargeSegment + xSmallSegment + xSmallSegment, ySegment));
            shape2.Add(new DoublePoint(xLargeSegment + xSmallSegment + 0, ySegment + ySegment));
            shape2.Add(new DoublePoint(xLargeSegment + xSmallSegment + xSmallSegment, ySegment + height));
            shape2.Add(new DoublePoint(xLargeSegment + xSmallSegment + xSmallSegment + xLargeSegment, ySegment + height));
            shape2.Add(new DoublePoint(xLargeSegment + xSmallSegment + width, ySegment + ySegment));

            pat.addPattern(shape1);
            pat.addPattern(shape2);
            setPattern(pat);
        }

        public SynthesisMetathesisRuleSpec(SpanFactory<ShapeNode> spanFactory, Pattern<Word, ShapeNode> pattern, string leftGroupName, string rightGroupName)
        {
            _spanFactory = spanFactory;
            _leftGroupName = leftGroupName;
            _rightGroupName = rightGroupName;

            _pattern = new Pattern<Word, ShapeNode>();
            foreach (PatternNode<Word, ShapeNode> node in pattern.Children)
            {
                var group = node as Group<Word, ShapeNode>;
                if (group != null)
                {
                    var newGroup = new Group<Word, ShapeNode>(group.Name);
                    foreach (Constraint<Word, ShapeNode> constraint in group.Children.Cast<Constraint<Word, ShapeNode>>())
                    {
                        Constraint<Word, ShapeNode> newConstraint = constraint.DeepClone();
                        newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
                        newGroup.Children.Add(newConstraint);
                    }
                    _pattern.Children.Add(newGroup);
                }
                else
                {
                    _pattern.Children.Add(node.DeepClone());
                }
            }
            _pattern.Freeze();
        }

		private void VisitMethodCall(MethodCallExpression expression)
		{
			VisitExpression(expression.Object);
			string methodName = expression.Method.Name;
			object objToInvokeUpon = returnValueFromLastExpressionVisit;

			MethodInfo methodInfo = objToInvokeUpon.GetType().GetMethod(methodName,
			                                                            BindingFlags.Public | BindingFlags.Instance);
			int paramCount = methodInfo.GetParameters().Count();
			Array paramArray = Array.CreateInstance(typeof (Object), paramCount);

			for (int arrLocation = 0; arrLocation < expression.Arguments.Count; arrLocation++)
			{
				Expression argument = expression.Arguments[arrLocation];
				VisitExpression(argument);
				if (argument is ConstantExpression)
				{
					object argValue = ((ConstantExpression) argument).Value;
					paramArray.SetValue(argValue, arrLocation);
				}
				else
				{
					object argValue = returnValueFromLastExpressionVisit;
					paramArray.SetValue(argValue, arrLocation);
					Console.WriteLine();
				}
			}
			var array = (object[]) paramArray;
			returnValueFromLastExpressionVisit = methodInfo.Invoke(objToInvokeUpon, array);
			if (returnValueFromLastExpressionVisit is Pattern)
			{
				m_pattern = (Pattern) returnValueFromLastExpressionVisit;
			}
		}