var i:Number;
var j:Number;
var exit:Boolean = false;
for (i=0; i<10; i++) {
    for (j=0; j<10; j++) {
        if (i > 3 && j > 3) {
            exit = true;
            break;
        }
    }
    if (exit) {
        break;
    }
}

var i:Number;
var j:Number;
mainLoop: for (i=0; i<10; i++) {
    for (j=0; j<10; j++) {
        if (i > 3 && j > 3) {
            break mainLoop;
        }
    }
}

traceThis.call(new Sprite()); // "Class Instance" 
 

func.call(null, a,b,c);

var m:int = 8
var t:String = m as String
var o:String = String(m)

trace(t) //null?
trace(o) //8 
 

package {
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.ui.Mouse;
    
    public class Test extends Sprite {
        
        private var cursor:Sprite = new Sprite();
        
        public function Test() {
            cursor.graphics.beginFill(0xFF);
            cursor.graphics.drawRect(0, 0, 25, 25);
            addChild(cursor);
            
            stage.addEventListener(Event.MOUSE_LEAVE, cursorHide);
            stage.addEventListener(MouseEvent.MOUSE_MOVE, cursorFollow);
            Mouse.hide();
        }
        
        public function cursorHide(evt:Event):void {
            cursor.visible = false;
        }
        
        public function cursorFollow(evt:MouseEvent):void {
            if (!cursor.visible) cursor.visible = true;
            cursor.x = stage.mouseX;
            cursor.y = stage.mouseY;
            evt.updateAfterEvent();
        }
    }
}

import mx.effects.Tween
var t = new Tween(mc, "_rotation", Elastic.easeOut, 0,360, 3, true)

var myButton:SimpleButton = new SimpleButton();

myButton.upState = mySprite1;
myButton.overState = mySprite2;
myButton.downState = mySprite3;
myButton.hitAreaState = mySprite4;

var myList:Array = [
    "The",
    "quick",
    "brown",
    "fox",
];

package my.package.path {
    class MyClass {
    }
}

// ActionScript 2:
class my.package.path.MyClass {
}

package {
    class NotInAPackageClass {
    }
}

package com.kirupa.utils {
    function StripString(str:String):void {
        // ...
    }
}

package {
    class MyClass {
        function MyClass() {
            var helper:MyHelper = new MyHelper();
        }
    }
}
class MyHelper {
    function MyHelper() {
        var helper:HelpersHelper = new HelpersHelper();
    }
}
class HelpersHelper {
    function HelpersHelper () {
    }
}

package {
    
    import flash.display.Sprite;
    
    // Application class needs to be public (internal by default)
    public class AccessControl extends Sprite {
        
        // constructors are always public
        function AccessControl() {
            
            // only classes in this file
            // can access helper classes
            var helper:Helper = new Helper();
            
            trace(helper.pubNum); // OK
            // trace(helper.protNum); // Error - cannot access protected
            // trace(helper.privNum); // Error - cannot access private
            trace(helper.interNum); // OK
        }
    }
}

// Helper class is implicitly internal
class Helper {
    
    // public access granted anywhere
    // variables are usually protected or
    // private with get/set used for public access
    public var pubNum:Number = 1;
    
    // protected access granted only for
    // subclasses in that class
    protected var protNum:Number = 2;
    
    // private access granted only in this class
    private var privNum:Number = 3;
    
    // internal access granted only in the same
    // package, but for helper classes, it means
    // only in the same file
    internal var interNum:Number = 4;
        
    // constructors are always public
    function Helper() {
    }
}

// SubHelper class is implicitly internal
// can extend other helper classes
class SubHelper extends Helper {
    
    // constructors are always public
    function SubHelper() {
        trace(pubNum); // OK
        trace(protNum); // OK - inherited
        // trace(privNum); // Error - cannot access private
        trace(interNum); // OK
    }
}

package {
    
    import flash.display.Sprite;
    import containers.*;
    
    // Application class needs to be public (internal by default)
    public class AccessControl extends Sprite {
        
        // constructors are always public
        function AccessControl() {
            
            // can access classes in other packages
            // only if public
            var bowl:Bowl = new Bowl(); // OK
            // var basket:Basket = new Basket(); // Error - cannot access internal
            
            trace(bowl.pubNum); // OK
            // trace(bowl.protNum); // Error - cannot access protected
            // trace(bowl.privNum); // Error - cannot access private
            // trace(bowl.interNum); // Error - cannot access internal
        }
    }
}

package containers {

    // public class accessible anywhere
    public class Bowl {
        
        // public access granted anywhere
        public var pubNum:Number = 1;
        
        // protected access granted only for
        // subclasses in that class
        protected var protNum:Number = 2;
        
        // private access granted only in this class
        private var privNum:Number = 3;
        
        // internal access granted only in the same package
        internal var interNum:Number = 4;
            
        // constructors are always public
        function Bowl() {
            
            // can access inteneral classes if in same package
            var basket:Basket = new Basket();
            
            trace(basket.pubNum); // OK
            // trace(basket.protNum); // Error - cannot access protected
            // trace(basket.privNum); // Error - cannot access private
            trace(basket.interNum); // OK - same package
            
            // clone using public method
            var basketCopy:Basket = basket.clone();
        }
    }
}

package containers {
    
    // interal only accessible
    // from other classes in package
    internal class Basket {
        
        // public access granted anywhere
        public var pubNum:Number = 1;
        
        // protected access granted only for
        // subclasses in that class
        protected var protNum:Number = 2;
        
        // private access granted only in this class
        private var privNum:Number = 3;
        
        // internal access granted only in the same package
        internal var interNum:Number = 4;
        
        // constructors are always public
        function Basket() {
        }
        
        // accessible anywhere as long as
        // referencing a Basket instance
        public function clone():Basket {
            var basket:Basket = new Basket();
            basket.pubNum = pubNum; // OK
            basket.protNum = protNum; // OK - same class
            basket.privNum = privNum; // OK - same class
            basket.interNum = interNum; // OK
            return basket;
        }
    }
}

package com.onebyonedesign.tests {
 
 import mx.effects.*;
 import flash.display.*;
 import flash.events.*;
 import mx.effects.easing.*;
 
 public class TweenTest extends Sprite {
  
  private var _circle:Sprite;
  
  function TweenTest() {
   stage.frameRate = 31;
   init();
  }
  
  private function init():void {
   _circle = makeCircle();
   _circle.addEventListener(MouseEvent.MOUSE_DOWN, tweenMe);
  }
  
  private function makeCircle():Sprite {
   var s:Sprite = new Sprite();
   s.graphics.beginFill(0x660000);
   s.graphics.drawCircle(20, 20, 20);
   addChild(s);
   return s;
  }
  
  private function updateTween(vals:Array):void {
   _circle.x = vals[0];
   _circle.y = vals[1];
  }
  
  private function endTween(vals:Array):void {
   trace ("ending coordinates: " + vals);
  }
  
  private function tweenMe(e:Event):void {
   var myTween:Tween = new Tween(_circle, [_circle.x, _circle.y], [275, 200], 1000, 31);
   myTween.easingFunction = Elastic.easeOut;
   myTween.setTweenHandlers(updateTween, endTween);
  }
 }
}

var a:Object = new Object();
var b:Object = new Object();

var dict: Dictionary = new Dictionary();
dict[a] = 1; // dict[a] = 1;
dict[b] = 2; // dict[b] = 2;


for (var prop:String in dict) {
     trace(prop); // traces: [object Object], [object Object]
     trace(dict[prop]); // traces: 1, 2
}

for (var prop:* in dict) {
     trace(prop); // traces: [object Object], [object Object]
     trace(dict[prop]); // traces: 1, 2
}

var myObj:InteractiveObject = new InteractiveObject(); // ERROR 
 

package {
    import flash.display.DisplayObject;
    public class MyDisplay extends DisplayObject{
        public function MyDisplay (){
            // ERROR
        }
    }
}

package {
    import flash.display.*;
    class MySprite extends Sprite {

        private var children:Array = new Array();

        public function MySprite() {
        }

        public override function addChild(child:DisplayObject):DisplayObject {
            children.push(child);
            super.addChild(child);
            return child;
        }
    }
}

package {
    
    import flash.display.Sprite;
    
    public dynamic class MyClass extends Sprite {
        
        public function MyClass(){
            
            // prototype = new Object(); // ERROR, cannot change prototype of class
            prototype.newValue = 1; // OK, adding (or removing) prototyped values
            
            trace(this.newValue); // 1
            trace(prototype.toString); // function Function() {}
            trace(prototype.addChild); // undefined
            trace(addChild); // function Function() {}

            // dynamic ("old style") class definition
            var TempClass:Function = function():void {
                trace("Create TempClass");
            }
            
            TempClass.prototype = prototype; // OK, can set up inheritance
            
            var tempObject:* = new TempClass(); // "Create TempClass"
            
            trace(tempObject.newValue); // 1
        }
    }
}

var reCon:RegExp = new RegExp("\\w+", "i");
var reLit:RegExp = /\w+/i;

var sortedItems:Array = new Array(mc1, mc2, mc3);
function arrange():void {
    sortedItems.sortOn("y", Array.NUMERIC);
    var i:int = sortedItems.length;
    while(i--){
        if (getChildAt(i) != sortedItems[i]) {
            setChildIndex(sortedItems[i], i);
        }
    }
}

function clone(source:Object):* {
    var copier:ByteArray = new ByteArray();
    copier.writeObject(source);
    copier.position = 0;
    return(copier.readObject());
}

newObjectCopy = clone(originalObject);

package {
    
    import flash.display.Sprite;
    
    public class MyApp extends Sprite {
    
        private var variable:String;
        private static var variable:String;
            
        public function MyApp() {         
            this.variable = "foo";
            MyApp.variable = "bar";
            
            trace(this.variable); // "foo"
            trace(MyApp.variable); // "bar"
            trace(variable); // "foo"
        }
    }
}

package {
    
    import flash.display.Sprite;
    import flash.events.Event;
    
    public class MyDispatcher extends Sprite {
        
        public function MyDispatcher() {
            addEventListener("customEvent", handleEvent);
            dispatchEvent(new Event("customEvent"));
        }
        
        private function handleEvent(event:Event):void {
            trace(event.type); // "customEvent"
        }
    }
}

package {
    
    import flash.display.Sprite;
    import flash.events.Event;
    
    public class MyDispatcher extends Sprite {
        
        public function MyDispatcher() {
            var dispatcher:CustomDispatcher = new CustomDispatche