     {
         super.playReversed = value;
         
-        if (animation)
+        if (value && animation)
             animation.reverse();
         
         reverseAnimation = value;

    private function finalizeValues():Boolean
    {
        var changedValues:Boolean = false;
        for (var i:int = 0; i < animationProperties.length; ++i)
        {
            var holder:AnimationProperty = 
                AnimationProperty(animationProperties[i]);
            // Note that we use strict equality tests for null, as a simple
            // '0' value for a Number or int would look the same as a null
            // in a simple !value test.
            // Let's hope they've set a reasonable interpolator by now,
            // or otherwise we're just dealing with numbers
            var interp:IInterpolator = 
                interpolator ?
                interpolator :
                NumberInterpolator.getInstance();
            var fromValid:Boolean = isValidValue(holder.valueFrom);
            var toValid:Boolean = isValidValue(holder.valueTo);
            var byValid:Boolean = isValidValue(holder.valueBy);
            if (!fromValid || !toValid)
            {
                if (!fromValid)
                {
                    if (toValid && byValid)
                        holder.valueFrom = interp.decrement(holder.valueTo, holder.valueBy);
                    else
                        holder.valueFrom = getCurrentValue(holder.property);
                    fromValid = isValidValue(holder.valueFrom);
                }
                if (!toValid)
                {
                    if (fromValid && byValid)
                        holder.valueTo = interp.increment(holder.valueFrom, holder.valueBy);
                    else
                        holder.valueTo = getCurrentValue(holder.property);
                }
                changedValues = true;
            }
        }
        return changedValues;

            return;
        }
            
        isStyleMap = new Array(animationProperties.length);        
    
        // TODO (chaase): avoid setting up animations on properties whose
        // from/to values are the same. Not worth the cycles, but also want
        // to avoid triggering any side effects when we're not actually changing
        // values
        var i:int;
        var j:int;
        for (i = 0; i < animationProperties.length; ++i)
        {
            var mp:MotionPath = MotionPath(animationProperties[i]);
            // TODO (chaase): should we push this keyframe-init logic
            // into the MotionPath class instead?
            
            // Create an initial (time==0) value if necessary 
            var keyframes:Array = animationProperties[i].keyframes;
            if (keyframes[0].time > 0)
            {
                keyframes.splice(0, 0, new KeyFrame(0, null));
                keyframes[0].timeFraction = 0;
            }
            if (interpolator)
                mp.interpolator = interpolator;
            // Fix the first and last values if necessary and possible
            var kf:KeyFrame = keyframes[keyframes.length - 1];
            if (!isValidValue(kf.value) &&
                propertyChanges &&
                propertyChanges.end[mp.property] !== undefined)
            {
                kf.value = propertyChanges.end[mp.property];
            }
            // adjust effect duration to be the max of all MotionPath keyframe times
            // TODO (chaase): Currently we do not adjust *down* for smaller duration
            // MotionPaths. This is because we do not distinguish between
            // AnimationProperty objects (which are created with fake durations of 1,
            // knowing that they will derive their duration from their effects) and
            // actual keyframe-based MotionPaths.
            for (j = 0; j < keyframes.length; ++j)
                duration = Math.max(duration, keyframes[j].time);

            mp.scaleKeyframes(keyframes[keyframes.length-1].time);
        }

        animation = new Animation(duration);
        animation.animationProperties = animationProperties;

        animation.addEventListener(AnimationEvent.ANIMATION_START, startHandler);
        animation.addEventListener(AnimationEvent.ANIMATION_UPDATE, updateHandler);
        animation.addEventListener(AnimationEvent.ANIMATION_REPEAT, repeatHandler);
