             
             // Step through the child effects in the sequence until we find the
             // set that the requested playheadTime is in
-            for (i = 0; i < activeEffectQueue.length; ++i)
-            {
+            var activeLength:Number = activeEffectQueue.length;
+            for (i = 0; i < activeLength; ++i)
+            {
+                var setToCompare:int = playReversed ? (activeLength - 1 - i) : i;
                 // temp holder for instances that we fast-forward or rewind
                 var childEffectInstances:Array;
                 // start/end times of current child effect we're looking at
                 var startTime:Number = cumulativeDuration;
-                var endTime:Number = cumulativeDuration + childSets[i][0].actualDuration;
+                var endTime:Number = cumulativeDuration + childSets[setToCompare][0].actualDuration;
                 cumulativeDuration = endTime;
                 
                 // If iterationPlayheadTime is in between the start and end time for this

        * to the one we should be playing. Play it and set playheadTime
        * appropriately
        */
        var i:int, j:int, k:int;
        var compositeDur:Number = Sequence(effect).compositeDuration;
        var firstCycleDur:Number = compositeDur + startDelay + repeatDelay;
        var laterCycleDur:Number = compositeDur + repeatDelay;

                    endEffectCalled = true;

                    // We're already playing the effect we should seek into
                    if (currentSetIndex == setToCompare)
                    {
                        // Since we're already playing the right effect, just seek
                        for (j = 0; j < currentSet.length; j++)
                            currentSet[j].playheadTime = (iterationPlayheadTime - startTime);
                    }
                    else if (setToCompare < currentSetIndex)
                    {
                        if (playReversed)
                        {
                            // We're currently playing a child effect later than the one we
                            // should seek into. First, rewind and stop the current effect
                            for (j = 0; j < currentSet.length; j++)
                                currentSet[j].end();
                            // Next, play(), then stop() the previous effects back to
                            // the one we want. This will cause these effects to set
                            // values for their target properties at the start
                            // of their animations, which is what we want when seeking
                            // backwards
                            // Next, play/end all child effects before the one we want
                            // This will set the animated properties to their end values.
                            for (j = currentSetIndex - 1; j > setToCompare; --j)
                            {
                                childEffectInstances = activeEffectQueue[j];
                                for (k = 0; k < childEffectInstances.length; k++)
                                {
                                    if (playReversed)
                                        childEffectInstances[k].playReversed = true;
                                    childEffectInstances[k].play();
                                    childEffectInstances[k].end();
                                }
                            }
                        }
                        else
                        {
                            // We're currently playing a child effect later than the one we
                            // should seek into. First, rewind and stop the current effect
                            for (j = 0; j < currentSet.length; j++)
                            {
                                currentSet[j].playheadTime = 0;
                                currentSet[j].stop();
                            }
                            // Next, play(), then stop() the previous effects back to
                            // the one we want. This will cause these effects to set
                            // values for their target properties at the start
                            // of their animations, which is what we want when seeking
                           // backwards
                            for (j = currentSetIndex - 1; j > setToCompare; --j)
                            {
                                childEffectInstances = activeEffectQueue[j];
                                for (k = 0; k < childEffectInstances.length; k++)
                                {
                                    childEffectInstances[k].play();
                                    childEffectInstances[k].stop();
                                }
                            }
                        }
                        // Now, play the right effect and seek into it
                        currentSetIndex = setToCompare;
                        playCurrentChildSet();
                        for (k = 0; k < currentSet.length; k++)
                        {
