      */
     private static function pre10_0_22_87_transformVector(m:Matrix3D,v:Vector3D):Vector3D
     {
-    	var r:Vector.<Number> = m.rawData;
-    	return new Vector3D(
-    		r[0] * v.x + r[4] * v.y + r[8] * v.z + r[12], 
-    		r[1] * v.x + r[5] * v.y + r[9] * v.z + r[13], 
-    		r[2] * v.x + r[6] * v.y + r[10] * v.z + r[14],
-    		1); 
+        var r:Vector.<Number> = m.rawData;
+        return new Vector3D(
+            r[0] * v.x + r[4] * v.y + r[8] * v.z + r[12], 
+            r[1] * v.x + r[5] * v.y + r[9] * v.z + r[13], 
+            r[2] * v.x + r[6] * v.y + r[10] * v.z + r[14],
+            1); 
     }
 
     /**

     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
	public function set layoutRotationY(value:Number):void
	{
		layout.rotationY= value;
		invalidate();
	}
	
    /**
     * @private
     */
	public function get layoutRotationY():Number
	{
		return layout.rotationY;
	}
	
    /**
     * layout transform convenience property.  Represents the rotation around the Z axis of the layout matrix used in layout and in 
     * the computed transform.

            y += postLayoutTransformOffsets.y;
            z += postLayoutTransformOffsets.z;
        }
            
        build3DMatrix(m, tx, ty, tz, sx, sy, sz, rx, ry, rz, x, y, z);
        // Always prepend last
        if (stretchX != 1 || stretchY != 1)
            m.prependScale(stretchX, stretchY, 1);  

        _flags |= COMPUTED_MATRIX3D_VALID;
        return m;           
    }
    
    
    /**
     * @private
     * convenience function for building a 2D matrix from the convenience properties 
     */
    public static function build2DMatrix(m:Matrix,
                                    tx:Number,ty:Number,
                                    sx:Number,sy:Number,
                                    rz:Number,
                                    x:Number,y:Number):void
    {
        m.translate(-tx,-ty);
        m.scale(sx,sy);
        m.rotate(rz* RADIANS_PER_DEGREES);
        m.translate(x+tx,y+ty);         
    }


    /**
     * @private
     * convenience function for building a 3D matrix from the convenience properties 
     */
    public static function build3DMatrix(m:Matrix3D,
                                        tx:Number,ty:Number,tz:Number,
                                        sx:Number,sy:Number,sz:Number,
                                        rx:Number,ry:Number,rz:Number,
                                        x:Number,y:Number,z:Number):void
    {
        reVR.x = rx * RADIANS_PER_DEGREES;
        reVR.y = ry * RADIANS_PER_DEGREES;
        reVR.z = rz * RADIANS_PER_DEGREES;
        m.recompose(reV);
        if(sx == 0)
            sx = ZERO_REPLACEMENT_IN_3D;
        if(sy == 0)
            sy = ZERO_REPLACEMENT_IN_3D;
        if(sz == 0)
            sz = ZERO_REPLACEMENT_IN_3D;
        m.prependScale(sx,sy,sz);
        m.prependTranslation(-tx,-ty,-tz);
        m.appendTranslation(tx+x,ty+y,tz+z);
    }                                   
                        

    /**
     * A utility method to update the rotation and scale of the transform 
     * while keeping a particular point, specified in the component's 
     * own coordinate space, fixed in the parent's coordinate space.  
     * This function will assign the rotation and scale values provided, 
     * then update the x/y/z properties as necessary to keep tx/ty/tz fixed.
     * @param rx,ry,rz the new values for the rotation of the transform
     * @param sx,sy,sz the new values for the scale of the transform
     * @param tx,ty,tz the point, in the component's own coordinates, 
     * to keep fixed relative to its parent.
     */
    public function transformPointToParent(propertyIs3D:Boolean,
        transformCenter:Vector3D, currentPosition:Vector3D,
        currentPostLayoutPosition:Vector3D):void
