internal IterIsolateEnumerator(IEnumerator enumerator)
            {
                // if this is the enumerator from another iterator, we
                    // don't have to enumerate it; we'll just steal the arraylist
                    // to use for ourselves.
                IterIsolateEnumerator chainedEnumerator =
                    enumerator as IterIsolateEnumerator;

                if (chainedEnumerator != null)
                {
                    items = chainedEnumerator.items;
                }
                else
                {
                    items = new ArrayList();
                    while (enumerator.MoveNext() != false)
                    {
                        items.Add(enumerator.Current);
                    }
                    IDisposable disposable = enumerator as IDisposable;
                    if (disposable != null)
                    {
                        disposable.Dispose();
                    }
                }
                currentItem = -1;
            }

    /*private bool firstTime=false;

    void OnTriggerStay2D(Collider2D theOther)
    { 
        player = theOther.transform.gameObject;
       
        if (pressingDown()&&!firstTime)
        {
            StartCoroutine(preparingRitual());
        }
    }
    void PlayDestroySound()
    {
        gameObject.GetComponent<AudioSource>().Play();

    }

    private bool pressingDown()
    {
        return Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow);
    }

    private IEnumerator preparingRitual()
    {
        firstTime = true;
        float startTime, actualTime, duration, time;
        bool ritualStarted = false;
        time = 1f;
        startTime = Time.time;
        while (pressingDown())
        {
            actualTime = Time.time;
            duration = actualTime - startTime;
            if (duration >= 2f && !ritualStarted)
            {
                startRitual();
                ritualStarted = true;
            }
            yield return new WaitForSeconds(time);
        }
        yield return null;
    }

    private void startRitual()
    {
        this.transform.gameObject.SetActive(false);
        player.GetComponent<StressUpdater>().decreaseAnxiety(0.5f);
        firstTime = false;
    }*/

    void OnTriggerEnter2D(Collider2D theOther)
    {
        player = theOther.transform.gameObject;
        player.gameObject.GetComponent<PlatformerCharacter2D>().triggerRitual();
        removeAnxietyCoroutine = removeAnxiety();
        StartCoroutine(removeAnxietyCoroutine);
    }

        private static StringBuilder ParseRoute(IEnumerator<char> tokenizer, StringBuilder routePattern, IDictionary<string, string> routeParametersVsNamedGroup, IList<string> queryParameters)
        {
            char nextCharacterInRoute = tokenizer.Current;

            if (nextCharacterInRoute == '{')
            {
                tokenizer.MoveNext();
                return ParseRouteParameter(tokenizer, routePattern, routeParametersVsNamedGroup, queryParameters);
            }
            else if (nextCharacterInRoute == '?')
            {
                routePattern.Append(Regex.Escape(nextCharacterInRoute.ToString(CultureInfo.InvariantCulture)));
                tokenizer.MoveNext();
                return ParseQueryStringParameters(tokenizer, routePattern, queryParameters);
            }
            else
            {
                routePattern.Append(Regex.Escape(nextCharacterInRoute.ToString(CultureInfo.InvariantCulture)));
                if (tokenizer.MoveNext())
                    return ParseRoute(tokenizer, routePattern, routeParametersVsNamedGroup, queryParameters);
                else
                    return routePattern;

            }
        }

        IEnumerator EnumeratorDecorator(IEnumerator enumerator, TaskRoutine task)
        {
            while (enumerator.MoveNext() == true)
                yield return enumerator.Current;

            _pool.Enqueue(task);
        }

 public PartiallyClosedCircuitBreakerState(CircuitBreaker breaker, Exception exception,
     IEnumerator<int> timeoutEnumerator)
     : base(breaker)
 {
     _exception = exception;
     _timeoutEnumerator = timeoutEnumerator;
 }

        private Sequence<InstructionNode> Create(IEnumerator<XamlInstruction> stream)
        {
            var nodes = new Sequence<InstructionNode>();

            while (IsLeading(stream.Current))
            {
                var currentNode = new InstructionNode { Leading = stream.Current };
                var continueWorking = true;
                while (stream.MoveNext() && continueWorking)
                {
                    if (IsLeading(stream.Current))
                    {
                        currentNode.Children = Create(stream);
                    }

                    var xamlNode = stream.Current;

                    if (IsTrailing(xamlNode))
                    {
                        continueWorking = false;
                        currentNode.Trailing = stream.Current;
                    }
                    else
                    {
                        currentNode.Body.Add(stream.Current);
                    }
                }

                nodes.Add(currentNode);
            }

            return nodes;
        }

 /// <summary>
 /// Parametrized constructor
 /// </summary>
 /// <param name="enumerator">enumerator that generates id for users(Fibonacci enumerator by default)</param>
 /// <param name="path">file path</param>
 public MemoryRepository(IEnumerator<int> enumerator, string path)
 {
     if (enumerator != null)
         _enumerator = enumerator;
     if (path != null)
         _xmlPath = path;
 }

 public EnumeratorSeq(IEnumerator enumerator)
 {
     _enumerator = enumerator;
     _state = new State();
     _state._val = _state;
     _state._rest = _state;
 }

        public override IEnumerable GetTestCases()
        {
            ArrayList testCases = new ArrayList();
#endif
            IEnumerator[] enumerators = new IEnumerator[Sources.Length];
            int index = -1;

            for (; ; )
            {
                while (++index < Sources.Length)
                {
                    enumerators[index] = Sources[index].GetEnumerator();
                    if (!enumerators[index].MoveNext())
						return testCases;
                }

                object[] testdata = new object[Sources.Length];

                for (int i = 0; i < Sources.Length; i++)
                    testdata[i] = enumerators[i].Current;

                ParameterSet parms = new ParameterSet();
                parms.Arguments = testdata;
				testCases.Add(parms);

                index = Sources.Length;

                while (--index >= 0 && !enumerators[index].MoveNext()) ;

                if (index < 0) break;
            }

			return testCases;
        }

 /// Creates a new Task object for the given coroutine.
 ///
 /// If autoStart is true (default) the task is automatically started
 /// upon construction.
 public Task(IEnumerator c, bool autoStart = true)
 {
     task = TaskManager.CreateTask(c);
     task.Finished += TaskFinished;
     if (autoStart)
         Start();
 }

		public virtual void AddAll(IEnumerator iterator)
		{
			while (iterator.MoveNext())
			{
				Add(iterator.Current);
			}
		}

        private static byte[] DecodeByteArray(IEnumerator<byte> enumerator)
        {
            List<byte> lengthBytes = new List<byte>();

            // scan until we get to divider
            do
            {
                if( enumerator.Current == ByteArrayDivider )
                    break;

                lengthBytes.Add(enumerator.Current);
            }
            while (enumerator.MoveNext());

            string lengthString = System.Text.Encoding.UTF8.GetString(lengthBytes.ToArray());

            int length;
            if (!Int32.TryParse(lengthString, out length))
                throw new Exception("unable to parse length of byte array");

            // now read in the actual byte array
            byte[] bytes = new byte[length];

            for (int i = 0; i < length; i++)
            {
                enumerator.MoveNext();
                bytes[i] = enumerator.Current;
            }

            return bytes;
        }

 /// <summary>
 /// Start a co-routine on a background thread.
 /// </summary>
 /// <param name="task">Gets a task object with more control on the background thread.</param>
 /// <returns></returns>
 public static Coroutine StartCoroutineAsync(
     this MonoBehaviour behaviour, IEnumerator routine, 
     out Task task)
 {
     task = new Task(routine);
     return behaviour.StartCoroutine(task);
 }

        internal Match(ParseStep parseStep, IEnumerator<ParseStep> stepEnumerator, IEnumerable<IList<ParenCapture>> captureSet)
            : base(0, parseStep.InitialStateIndex, parseStep.MatchedText.Length, parseStep.MatchedText, true)
        {
            _stepEnumerator = stepEnumerator;
            Groups = new GroupCollection();
            Groups.Append(this);
            Captures.Prepend(this);

            foreach (var parenCaptures in captureSet)
            {
                var parenCapture = parenCaptures[0];

                var group = new Group(parenCapture.Number,
                                      parenCapture.Index,
                                      parenCapture.Value.Length,
                                      parenCapture.Value,
                                      parenCapture.Success);
                Groups.Append(group);

                if (parenCapture.Success)
                {
                    group.Captures.Prepend(group);
                }

                if (parenCaptures.Skip(1).All(c => c.Success))
                {
                    for (int i = 1; i < parenCaptures.Count; i++)
                    {
                        group.Captures.Prepend(new Capture(parenCaptures[i].Index,
                                                           parenCaptures[i].Value.Length,
                                                           parenCaptures[i].Value));
                    }
                }
            }
        }

        private static StringBuilder ParseQueryStringParameters(IEnumerator<char> tokenizer, StringBuilder routePattern, IList<string> queryParameters)
        {
            var parameterName = new StringBuilder();

            bool endOfStream = false;

            while (!endOfStream && tokenizer.Current != '&')
            {
                parameterName.Append(tokenizer.Current);
                endOfStream = !tokenizer.MoveNext();
            }

            string param = parameterName.ToString();
            routePattern.Append(string.Format(@"(?<{0}{2}>[^=\?&]+)=(?<{1}{2}>[^&]+)", QueryParameterGroupName, QueryParameterValueGroupName, queryParameters.Count));
            queryParameters.Add(param);

            if (endOfStream)
                return routePattern;
            else
            {
                routePattern.Append(Regex.Escape(tokenizer.Current.ToString(CultureInfo.InvariantCulture)));
                tokenizer.MoveNext();
                return ParseQueryStringParameters(tokenizer, routePattern, queryParameters);
            }
        }

		private void CollectIndexedNodes(IEnumerator qcons)
		{
			while (qcons.MoveNext())
			{
				QCon qcon = (QCon)qcons.Current;
				if (IsCached(qcon))
				{
					continue;
				}
				if (IsLeaf(qcon))
				{
					if (qcon.CanLoadByIndex() && qcon.CanBeIndexLeaf())
					{
						QConObject conObject = (QConObject)qcon;
						if (conObject.HasJoins())
						{
							CollectJoinedNode(conObject);
						}
						else
						{
							CollectStandaloneNode(conObject);
						}
					}
				}
				else
				{
					if (!qcon.HasJoins())
					{
						CollectIndexedNodes(qcon.IterateChildren());
					}
				}
			}
		}

 void Awake()
 {
     watcherCoroutine = extendedFingerWatcher();
       if(HandModel == null){
     HandModel = gameObject.GetComponentInParent<IHandModel>();
       }
 }

 public virtual void Next()
 {
     if (enumerator == null)
     {
         enumerator = Steps.GetEnumerator();
         enumerator.MoveNext();
         step = enumerator.Current;
         this.OnNext(Step);
     }
     else
     {
         if (Step != Steps.Last())
         {
             enumerator.MoveNext();
             step = enumerator.Current;
             this.OnNext(Step);
         }
         else
         {
             if (OnFinished != null)
             {
                 OnFinished();
             }
         }
     }
 }

 /// <summary>
 /// Construct an enumerator over the out-edges
 /// </summary>
 /// <param name="vertexOutEdges">Out edge dictionary to iterate</param>
 /// <exception cref="ArgumentNullException">vertexOutEdges is null</exception>
 public VertexEdgesEnumerator(VertexEdgesDictionary vertexOutEdges)
 {
     if (vertexOutEdges == null)
         throw new ArgumentNullException("vertexOutEdges");
     VertexOutEdgeEnumerator = vertexOutEdges.GetEnumerator();
     OutEdgeEnumerator = null;
 }

    public void ShowLetter(int num)
    {
        if(currentCourutine != null)
        {
            StopCoroutine(currentCourutine);
            currentCourutine = null;
        }

        full.SetActive(true);
        letters[num].SetActive(true);
        letters[num].transform.localScale = new Vector3(4f, 4f, 4f);

        iTween.ScaleTo(letters[num].gameObject,
           iTween.Hash(
               "scale", new Vector3(1, 1, 1),
               "time", 0.45f,
              /* "onstart", (System.Action<object>)(newVal => logo1.color = new Color(logo1.color.r, logo1.color.g, logo1.color.b, 1)),*/
               "easetype", iTween.EaseType.easeInCubic,
               "oncomplete", "ShakeCamera",
               "oncompletetarget", gameObject
               )
            );

        currentCourutine = HideFull();
        StartCoroutine(currentCourutine);
    }