                     endEffectCalled = true;
 
                     // We're already playing the effect we should seek into
-                    if (currentSetIndex == i)
+                    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 (i < currentSetIndex)
+                    else if (setToCompare < currentSetIndex)
                     {
-                        // 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++)
+                        if (playReversed)
                         {
-                            currentSet[j].playheadTime = 0;
-                            currentSet[j].stop();
+                            // 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();
+                                }
+                            }
                         }
-                        // 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 > i; --j)
+                        else
                         {
-                            childEffectInstances = activeEffectQueue[j];
-                            for (k = 0; k < childEffectInstances.length; k++)
+                            // 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++)
                             {
-                                childEffectInstances[k].play();
-                                childEffectInstances[k].stop();
+                                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 = i;
+                        currentSetIndex = setToCompare;
                         playCurrentChildSet();
                         for (k = 0; k < currentSet.length; k++)
                         {

                            if (isPaused)
                                currentSet[k].pause();
                        }
                        break;
                    }
                    else // i > currentSetIndex
                    {
                        // We need to seek into a child effect later than the
                        // one we're currently playing. First, end the current effect.
                        var currentEffectInstances:Array = currentSet.concat();
                        for (j = 0; j < currentEffectInstances.length; j++)
                            currentEffectInstances[j].end();
                        
                        // Next, play/end all child effects before the one we want
                        // This will set the animated properties to their end values.
                        for (k = currentSetIndex + 1; k < i; k++)
                        {
                            childEffectInstances = activeEffectQueue[k];                          
                            for (var l:int = 0; l < childEffectInstances.length; l++)
                            {
                                childEffectInstances[l].play();
                                childEffectInstances[l].end();
                            }
                        }
                        // Finally, set the current child effect and seek into it
                        currentSetIndex = i;
                        playCurrentChildSet();
                        for (k = 0; k < currentSet.length; k++)
                        {

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