function MovieClip(props) {
		this.Container_constructor();
		!MovieClip.inited&&MovieClip.init(); // static init
		
		var mode, startPosition, loop, labels;
		
		// handle old params (mode, startPosition, loop, labels):
		// TODO: deprecated param handling:
		if (props instanceof String || arguments.length > 1) {
			mode = props;
			startPosition = arguments[1];
			loop = arguments[2];
			labels = arguments[3];
			if (loop == null) { loop = -1; }
			props = null;
		} else if (props) {
			mode = props.mode;
			startPosition = props.startPosition;
			loop = props.loop;
			labels = props.labels;
		}
		if (!props) { props = {labels:labels}; }
		
		
	// public properties:
		/**
		 * Controls how this MovieClip advances its time. Must be one of 0 (INDEPENDENT), 1 (SINGLE_FRAME), or 2 (SYNCHED).
		 * See each constant for a description of the behaviour.
		 * @property mode
		 * @type String
		 * @default null
		 **/
		this.mode = mode||MovieClip.INDEPENDENT;
	
		/**
		 * Specifies what the first frame to play in this movieclip, or the only frame to display if mode is SINGLE_FRAME.
		 * @property startPosition
		 * @type Number
		 * @default 0
		 */
		this.startPosition = startPosition||0;
	
		/**
		 * Specifies how many times this MovieClip should loop. A value of -1 indicates it should loop indefinitely. A value of
		 * 1 would cause it to loop once (ie. play a total of twice).
		 * @property loop
		 * @type Number
		 * @default -1
		 */
		this.loop = loop === true ? -1 : (loop || 0);
	
		/**
		 * The current frame of the movieclip.
		 * @property currentFrame
		 * @type Number
		 * @default 0
		 * @readonly
		 */
		this.currentFrame = 0;
	
		/**
		 * If true, the MovieClip's position will not advance when ticked.
		 * @property paused
		 * @type Boolean
		 * @default false
		 */
		this.paused = props.paused||false;
	
		/**
		 * If true, actions in this MovieClip's tweens will be run when the playhead advances.
		 * @property actionsEnabled
		 * @type Boolean
		 * @default true
		 */
		this.actionsEnabled = true;
	
		/**
		 * If true, the MovieClip will automatically be reset to its first frame whenever the timeline adds
		 * it back onto the display list. This only applies to MovieClip instances with `mode` of "INDEPENDENT".

		 * For example, if you had a character animation with a "body" child MovieClip instance with different costumes
		 * on each frame, you could set `body.autoReset = false`, so that you can manually change the frame it is on,
		 * without worrying that it will be reset automatically.
		 * @property autoReset
		 * @type Boolean
		 * @default true
		 */
		this.autoReset = true;
		
		/**
		 * An array of bounds for each frame in the MovieClip. This is mainly intended for tool output.
		 * @property frameBounds
		 * @type Array
		 * @default null
		 */
		this.frameBounds = this.frameBounds||props.frameBounds; // frameBounds are set on the prototype in Animate.
		
		/**
		 * By default MovieClip instances advance one frame per tick. Specifying a framerate for the MovieClip
		 * will cause it to advance based on elapsed time between ticks as appropriate to maintain the target
		 * framerate.
		 *
		 * For example, if a MovieClip with a framerate of 10 is placed on a Stage being updated at 40fps, then the MovieClip will
		 * advance roughly one frame every 4 ticks. This will not be exact, because the time between each tick will
		 * vary slightly between frames.
		 *
		 * This feature is dependent on the tick event object (or an object with an appropriate "delta" property) being
		 * passed into {{#crossLink "Stage/update"}}{{/crossLink}}.
		 * @property framerate
		 * @type {Number}
		 * @default null
		 **/
		this.framerate = null;
		
		// set up the needed props for Timeline:
		props.useTicks = props.paused = true;
		
		/**
		 * The TweenJS Timeline that is associated with this MovieClip. This is created automatically when the MovieClip
		 * instance is initialized. Animations are created by adding <a href="http://tweenjs.com">TweenJS</a> Tween
		 * instances to the timeline.
		 *
		 * <h4>Example</h4>
		 *
		 *      var tween = createjs.Tween.get(target).to({x:0}).to({x:100}, 30);
		 *      var mc = new createjs.MovieClip();
		 *      mc.timeline.addTween(tween);
		 *
		 * Elements can be added and removed from the timeline by toggling an "_off" property
		 * using the `tweenInstance.to()` method. Note that using `Tween.set` is not recommended to create MovieClip
		 * animations. The following example will toggle the target off on frame 0, and then back on for frame 1. You
		 * can use the "visible" property to achieve the same effect.
		 *
		 *      var tween = createjs.Tween.get(target).to({_off:false})
		 *          .wait(1).to({_off:true})
		 *          .wait(1).to({_off:false});
		 *
		 * @property timeline
		 * @type Timeline
		 * @default null
		 */
		this.timeline = new createjs.Timeline(props);
		
		
	// private properties:
		/**
		 * @property _synchOffset
		 * @type Number
		 * @default 0
		 * @private
		 */
		this._synchOffset = 0;
	
		/**
		 * @property _rawPosition
		 * @type Number
		 * @default -1
		 * @private
		 */
		this._rawPosition = -1; // TODO: evaluate using a ._reset Boolean prop instead of -1.
		
		/**
		 * @property _bound_resolveState
		 * @type Function
		 * @private
		 */
		this._bound_resolveState = this._resolveState.bind(this);
	
	
		/**
		 * The time remaining from the previous tick, only applicable when .framerate is set.
		 * @property _t
		 * @type Number
		 * @private
		 */
		this._t = 0;
	
		/**
		 * List of display objects that are actively being managed by the MovieClip.
		 * @property _managed
		 * @type Object
		 * @private
		 */
		this._managed = {};
	}
The MovieClip class associates a TweenJS Timeline with an EaselJS {{#crossLink "Container"}}{{/crossLink}}. It allows
you to create objects which encapsulate timeline animations, state changes, and synched actions. The MovieClip
class has been included in the EaselJS minified file since 0.7.0.

Currently MovieClip only works properly if it is tick based (as opposed to time based) though some concessions have
been made to support time-based timelines in the future.

<h4>Example</h4>
This example animates two shapes back and forth. The grey shape starts on the left, but we jump to a mid-point in
the animation using {{#crossLink "MovieClip/gotoAndPlay"}}{{/crossLink}}.

     var stage = new createjs.Stage("canvas");
     createjs.Ticker.addEventListener("tick", stage);

     var mc = new createjs.MovieClip({loop:-1, labels:{myLabel:20}});
     stage.addChild(mc);

     var child1 = new createjs.Shape(
         new createjs.Graphics().beginFill("#999999")
             .drawCircle(30,30,30));
     var child2 = new createjs.Shape(
         new createjs.Graphics().beginFill("#5a9cfb")
             .drawCircle(30,30,30));

     mc.timeline.addTween(
         createjs.Tween.get(child1)
             .to({x:0}).to({x:60}, 50).to({x:0}, 50));
     mc.timeline.addTween(
         createjs.Tween.get(child2)
             .to({x:60}).to({x:0}, 50).to({x:60}, 50));

     mc.gotoAndPlay("start");

It is recommended to use `tween.to()` to animate and set properties (use no duration to have it set
immediately), and the `tween.wait()`method to create delays between animations. Note that using the
`tween.set()` method to affect properties will likely not provide the desired result.

@class MovieClip
@main MovieClip
@param {Object} [props] The configuration properties to apply to this instance (ex. `{mode:MovieClip.SYNCHED}`).
Supported props for the MovieClip are listed below. These props are set on the corresponding instance properties
except where specified.<UL>
   <LI> `mode`</LI>
   <LI> `startPosition`</LI>
   <LI> `frameBounds`</LI>
</UL>

This object will also be passed into the Timeline instance associated with this MovieClip. See the documentation
for Timeline for a list of supported props (ex. `paused`, `labels`, `loop`, `reversed`, etc.)
@extends Container
@constructor