define("displayEngineApi", ["PIXI", "BABYLON"],
    function(PIXI, BABYLON) {
        "use strict";

        function $iterator(o) {
            if (o instanceof Array) return function() {
                return {
                    cur: 0,
                    arr: o,
                    hasNext: function() {
                        return this.cur < this.arr.length;
                    },
                    next: function() {
                        return this.arr[this.cur++];
                    }
                };
            };
            return typeof(o.iterator) == 'function' ? $bind(o, o.iterator) : o.iterator;
        };;
        var $fid = 0;

        function $bind(o, m) {
            if (m == null) return null;
            if (m.__id__ == null) m.__id__ = $fid++;
            var f;
            if (o.hx__closures__ == null) o.hx__closures__ = {};
            else f = o.hx__closures__[m.__id__];
            if (f == null) {
                f = function() {
                    return f.method.apply(f.scope, arguments);
                };
                f.scope = o;
                f.method = m;
                o.hx__closures__[m.__id__] = f;
            }
            return f;
        };
        var $_;
        var $estr = function() {
            return _hcmn_.js_Boot.__string_rec(this, '');
        };
        if (typeof displayEngineApi == 'undefined') {
            var displayEngineApi = {};
        };
        displayEngineApi.BitmapFilter = {
            __ename__: ["displayEngineApi", "BitmapFilter"],
            __constructs__: ["NONE", "GRAYSCALE", "CONVOLUTION", "INVERT", "RGB_TO_BRG", "RGB_TO_RBG", "RGB_TO_GBR", "RGB_TO_BGR", "RGB_TO_GRB", "GRADIENT", "SEPIA1", "SEPIA2", "GAMMA", "BRIGHTNESS", "NOISE", "SATURATION"]
        };
        displayEngineApi.BitmapFilter.SEPIA2 = ["SEPIA2", 11];
        displayEngineApi.BitmapFilter.SEPIA2.toString = $estr;
        displayEngineApi.BitmapFilter.SEPIA2.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.RGB_TO_BGR = ["RGB_TO_BGR", 7];
        displayEngineApi.BitmapFilter.RGB_TO_BGR.toString = $estr;
        displayEngineApi.BitmapFilter.RGB_TO_BGR.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.GRAYSCALE = ["GRAYSCALE", 1];
        displayEngineApi.BitmapFilter.GRAYSCALE.toString = $estr;
        displayEngineApi.BitmapFilter.GRAYSCALE.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.NONE = ["NONE", 0];
        displayEngineApi.BitmapFilter.NONE.toString = $estr;
        displayEngineApi.BitmapFilter.NONE.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.RGB_TO_BRG = ["RGB_TO_BRG", 4];
        displayEngineApi.BitmapFilter.RGB_TO_BRG.toString = $estr;
        displayEngineApi.BitmapFilter.RGB_TO_BRG.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.GAMMA = ["GAMMA", 12];
        displayEngineApi.BitmapFilter.GAMMA.toString = $estr;
        displayEngineApi.BitmapFilter.GAMMA.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.RGB_TO_GBR = ["RGB_TO_GBR", 6];
        displayEngineApi.BitmapFilter.RGB_TO_GBR.toString = $estr;
        displayEngineApi.BitmapFilter.RGB_TO_GBR.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.RGB_TO_GRB = ["RGB_TO_GRB", 8];
        displayEngineApi.BitmapFilter.RGB_TO_GRB.toString = $estr;
        displayEngineApi.BitmapFilter.RGB_TO_GRB.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.RGB_TO_RBG = ["RGB_TO_RBG", 5];
        displayEngineApi.BitmapFilter.RGB_TO_RBG.toString = $estr;
        displayEngineApi.BitmapFilter.RGB_TO_RBG.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.SATURATION = ["SATURATION", 15];
        displayEngineApi.BitmapFilter.SATURATION.toString = $estr;
        displayEngineApi.BitmapFilter.SATURATION.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.GRADIENT = ["GRADIENT", 9];
        displayEngineApi.BitmapFilter.GRADIENT.toString = $estr;
        displayEngineApi.BitmapFilter.GRADIENT.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.INVERT = ["INVERT", 3];
        displayEngineApi.BitmapFilter.INVERT.toString = $estr;
        displayEngineApi.BitmapFilter.INVERT.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.NOISE = ["NOISE", 14];
        displayEngineApi.BitmapFilter.NOISE.toString = $estr;
        displayEngineApi.BitmapFilter.NOISE.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.CONVOLUTION = ["CONVOLUTION", 2];
        displayEngineApi.BitmapFilter.CONVOLUTION.toString = $estr;
        displayEngineApi.BitmapFilter.CONVOLUTION.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.BRIGHTNESS = ["BRIGHTNESS", 13];
        displayEngineApi.BitmapFilter.BRIGHTNESS.toString = $estr;
        displayEngineApi.BitmapFilter.BRIGHTNESS.__enum__ = displayEngineApi.BitmapFilter;
        displayEngineApi.BitmapFilter.SEPIA1 = ["SEPIA1", 10];
        displayEngineApi.BitmapFilter.SEPIA1.toString = $estr;
        displayEngineApi.BitmapFilter.SEPIA1.__enum__ = displayEngineApi.BitmapFilter;

        displayEngineApi.IAnimation = function() {}
        displayEngineApi.IAnimation.prototype = {

            start: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IDisplayObject = function() {}
        displayEngineApi.IDisplayObject.prototype = {

            getId: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            setCacheAsBitmap: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getCacheAsBitmap: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            },
            getName: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            getParent: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getPivot: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setPivot: function(point) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getWidth: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setWidth: function(width) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getHeight: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setHeight: function(heigh) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getAlpha: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setAlpha: function(alpha) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getRotation: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setRotation: function(rotation) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setX: function(x) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setY: function(y) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            setPos: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            setDim: function(width, height) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            getScaleX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleX: function(scalex) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getScaleY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleY: function(scaley) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            setScale: function(factor) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getZIndex: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setZIndex: function(zIndex) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getZOrder: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setZOrder: function(zIndex) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            sendToBottom: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            bringToTop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getCursor: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            setCursor: function(cursor) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            },
            getButtonMode: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setButtonMode: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getMask: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setMask: function(graphics) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getHitArea: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setHitArea: function(area) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            getMouseEnabled: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setMouseEnabled: function(mouseEnabled) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getVisible: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setVisible: function(visible) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            updateCache: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getBounds: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setBounds: function(x, y, width, height) {
                return {
                    arguments: ["number", "number", "number", "number"],
                    returns: "void"
                };
            },
            globalToLocal: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            },
            localToGlobal: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            },
            on: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            off: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            onAddedToStage: function(handler) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getStageName: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            isType: function(type) {
                return {
                    arguments: ["*"],
                    returns: "boolean"
                };
            },
            setDraggable: function(draggable) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            isDraggable: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setDragBounds: function(bounds) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getDragBounds: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getUserData: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IBitmap = function() {}
        displayEngineApi.IBitmap.prototype = {

            clone: function(filter) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            getFiltered: function(filter, params) {
                return {
                    arguments: ["*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            update: function(c, width, height) {
                return {
                    arguments: ["*", "number", "*"],
                    returns: "void"
                };
            },
            getInfo: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            renderNoise: function(r, g, b, a) {
                return {
                    arguments: ["*", "*", "*", "number"],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IBitmapText = function() {}
        displayEngineApi.IBitmapText.prototype = {

            get_text: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            set_text: function(value) {
                return {
                    arguments: ["string"],
                    returns: "string"
                };
            },
            get_align: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            set_align: function(value) {
                return {
                    arguments: ["string"],
                    returns: "string"
                };
            }
        };

        displayEngineApi.IDisplayObjectContainer = function() {}
        displayEngineApi.IDisplayObjectContainer.prototype = {

            getNumChildren: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getChildren: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            },
            addChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            addChildAt: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "*"
                };
            },
            addChildren: function(children) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            removeChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            removeChildAt: function(index) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            removeChildren: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getChildAt: function(index) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getChildIndex: function(child) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            setChildIndex: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "void"
                };
            },
            getChildByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IGraphics = function() {}
        displayEngineApi.IGraphics.prototype = {

            arc: function(cx, cy, radius, startAngle, endAngle, anticlockwise, cache) {
                return {
                    arguments: ["number", "number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }, {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            clear: function(cache) {
                return {
                    arguments: [{
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            clone: function(fillColor, fillAlpha, strokeColor, strokeThickness, strokeAlpha) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            update: function(fillColor, fillAlpha, strokeColor, strokeThickness, strokeAlpha) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            beginFill: function(color, alpha, cache) {
                return {
                    arguments: ["number", {
                        type: "number",
                        opt: true
                    }, {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            lineStyle: function(thickness, color, alpha, cache) {
                return {
                    arguments: ["number", "number", {
                        type: "number",
                        opt: true
                    }, {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            moveTo: function(x, y, cache) {
                return {
                    arguments: ["number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            lineTo: function(x, y, cache) {
                return {
                    arguments: ["number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            drawRect: function(x, y, width, height, cache) {
                return {
                    arguments: ["number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            drawRoundRect: function(x, y, width, height, borderRadius, cache) {
                return {
                    arguments: ["number", "number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            drawCircle: function(x, y, radius, cache) {
                return {
                    arguments: ["number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            drawEllipse: function(x, y, width, height, cache) {
                return {
                    arguments: ["number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            drawPoly: function(polyDef, close, cache) {
                return {
                    arguments: ["*", {
                        type: "boolean",
                        opt: true
                    }, {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            bezierCurveTo: function(cpX, cpY, cpX2, cpY2, toX, toY, cache) {
                return {
                    arguments: ["number", "number", "number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            quadraticCurveTo: function(cpX, cpY, toX, toY, cache) {
                return {
                    arguments: ["number", "number", "number", "number", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            endFill: function(cache) {
                return {
                    arguments: [{
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            endStroke: function(cache) {
                return {
                    arguments: [{
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IMovieClip = function() {}
        displayEngineApi.IMovieClip.prototype = {

            getEnabled: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setEnabled: function(enabled) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getAnimationSpeed: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setAnimationSpeed: function(speed) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getPaused: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setPaused: function(paused) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getLoop: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setLoop: function(loop) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getCurrentFrame: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setCurrentFrame: function(frame) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getStateFrameCount: function(stateName) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "number"
                };
            },
            gotoAndPlay: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            applyPNGMask: function(mask) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            toBitmap: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            gotoAndStop: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            gotoAndPlayReversed: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            gotoAndStopReversed: function(scene, fromFrame) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            nextFrame: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            prevFrame: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            nextScene: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            prevScene: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            play: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            clone: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getOffscreenBitmaps: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            }
        };

        displayEngineApi.IOffscreenStage = function() {}
        displayEngineApi.IOffscreenStage.prototype = {

            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            addBitmapChild: function(bmp) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getCanvas: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getMaskedCanvas: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            applyMask: function(mask) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            getRegisteredBitmaps: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            },
            getWidth: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getHeight: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            }
        };

        displayEngineApi.IParticleSystem = function() {}
        displayEngineApi.IParticleSystem.prototype = {

            start: function(stage, path, loop) {
                return {
                    arguments: ["*", {
                        type: "*",
                        opt: true
                    }, {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            stop: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            moveTo: function(x, y) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.ISprite = function() {}
        displayEngineApi.ISprite.prototype = {

            getGraphics: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IStage = function() {}
        displayEngineApi.IStage.prototype = {

            getFpsInfo: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getId: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            getRenderer: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getRendererType: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getTimingMode: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setTimingMode: function(mode) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            setFPS: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getCanvas: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHeight: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setHeight: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getWidth: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setWidth: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getScaleX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleX: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getScaleY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setScaleY: function(val) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            setSize: function(width, height) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            getAlpha: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setAlpha: function(alpha) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getVisible: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            setVisible: function(val) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getMouse: function(event) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            render: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            addChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            addChildAt: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "void"
                };
            },
            addChildren: function(_children_) {
                return {
                    arguments: ["array"],
                    returns: "void"
                };
            },
            removeChild: function(child) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            removeChildAt: function(index) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            getChildIndex: function(child) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            setChildIndex: function(child, index) {
                return {
                    arguments: ["*", "number"],
                    returns: "void"
                };
            },
            getChildAt: function(index) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getChildByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            removeAllChildren: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getNumChildren: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getDeltaTime: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            getChildren: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            },
            on: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            off: function(type, listener, useCapture) {
                return {
                    arguments: ["string", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            offAll: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            onWindowTouch: function(handler, fireOnlyOnce) {
                return {
                    arguments: ["*", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IStage3D = function() {}
        displayEngineApi.IStage3D.prototype = {

            loadScene: function(fileContent) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            },
            importMesh: function(meshesNames, fileContent, onLoad) {
                return {
                    arguments: ["array", "string", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            stopRendering: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            resumeRendering: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getScene: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getEngine: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            beginAnimation: function(target, from, to, loop, speedRatio, onAnimationEnd, animatable) {
                return {
                    arguments: ["*", "number", "number", {
                        type: "boolean",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            stopAnimation: function(target) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            setHardwareScalingLevel: function(level) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getHardwareScalingLevel: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setSize: function(width, height) {
                return {
                    arguments: ["number", "number"],
                    returns: "void"
                };
            },
            getMeshByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getMeshByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getLastMeshByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            isActiveMesh: function(mesh) {
                return {
                    arguments: ["*"],
                    returns: "boolean"
                };
            },
            getLightByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getLightByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getLightByUniqueID: function(uniqueId) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getLastSkeletonByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getSkeletonByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getSkeletonByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getMaterialByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getMaterialByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getMultiMaterialByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getMultiMaterialByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getCameraByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getCameraByUniqueID: function(uniqueId) {
                return {
                    arguments: ["number"],
                    returns: "*"
                };
            },
            getCameraByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            switchActiveCamera: function(newCamera, control) {
                return {
                    arguments: ["*", {
                        type: "boolean",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            getLensFlareSystemByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getLensFlareSystemByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getBoneByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getBoneByName: function(name) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getParticleSystemByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            getGeometryByID: function(id) {
                return {
                    arguments: ["string"],
                    returns: "*"
                };
            },
            removeMesh: function(toRemove) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            removeSkeleton: function(toRemove) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            removeMorphTargetManager: function(toRemove) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            removeLight: function(toRemove) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            removeCamera: function(toRemove) {
                return {
                    arguments: ["*"],
                    returns: "number"
                };
            },
            registerBeforeRender: function(handler) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            registerAfterRender: function(handler) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            unregisterBeforeRender: function(handler) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            unregisterAfterRender: function(handler) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            }
        };

        displayEngineApi.ITicker = function() {}
        displayEngineApi.ITicker.prototype = {

            setInterval: function(interval) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getInterval: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setFPS: function(value) {
                return {
                    arguments: ["number"],
                    returns: "void"
                };
            },
            getFPS: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            setup: function(timingMode, renderer, targetFPS, maxDelta) {
                return {
                    arguments: ["*", "*", {
                        type: "number",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            init: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            reset: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getMeasuredTickTime: function(ticks) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            getMeasuredFPS: function(ticks) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            setPaused: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getPaused: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            getTime: function(runTime) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            getEventTime: function(runTime) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            getTicks: function(paused) {
                return {
                    arguments: ["boolean"],
                    returns: "number"
                };
            }
        };
        displayEngineApi.LineStyle = function(lineWidth, color, alpha) {
            this.lineWidth = lineWidth;
            this.color = color;
            this.alpha = alpha;
        };
        displayEngineApi.LineStyle.__name__ = ["displayEngineApi", "LineStyle"];
        displayEngineApi.LineStyle.prototype.lineWidth = null;
        displayEngineApi.LineStyle.prototype.color = null;
        displayEngineApi.LineStyle.prototype.alpha = null;
        displayEngineApi.LineStyle.prototype.__class__ = displayEngineApi.LineStyle;
        displayEngineApi.RendererName = {
            __ename__: ["displayEngineApi", "RendererName"],
            __constructs__: ["PIXI", "EASEL"]
        };
        displayEngineApi.RendererName.PIXI = ["PIXI", 0];
        displayEngineApi.RendererName.PIXI.toString = $estr;
        displayEngineApi.RendererName.PIXI.__enum__ = displayEngineApi.RendererName;
        displayEngineApi.RendererName.EASEL = ["EASEL", 1];
        displayEngineApi.RendererName.EASEL.toString = $estr;
        displayEngineApi.RendererName.EASEL.__enum__ = displayEngineApi.RendererName;
        displayEngineApi.RendererType = {
            __ename__: ["displayEngineApi", "RendererType"],
            __constructs__: ["RENDERER_CANVAS", "RENDERER_WEBGL"]
        };
        displayEngineApi.RendererType.RENDERER_CANVAS = ["RENDERER_CANVAS", 0];
        displayEngineApi.RendererType.RENDERER_CANVAS.toString = $estr;
        displayEngineApi.RendererType.RENDERER_CANVAS.__enum__ = displayEngineApi.RendererType;
        displayEngineApi.RendererType.RENDERER_WEBGL = ["RENDERER_WEBGL", 1];
        displayEngineApi.RendererType.RENDERER_WEBGL.toString = $estr;
        displayEngineApi.RendererType.RENDERER_WEBGL.__enum__ = displayEngineApi.RendererType;
        displayEngineApi.TimingMode = {
            __ename__: ["displayEngineApi", "TimingMode"],
            __constructs__: ["RAF", "TIMEOUT", "RAF_SYNCHED", "ONCE"]
        };
        displayEngineApi.TimingMode.RAF_SYNCHED = ["RAF_SYNCHED", 2];
        displayEngineApi.TimingMode.RAF_SYNCHED.toString = $estr;
        displayEngineApi.TimingMode.RAF_SYNCHED.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.TimingMode.ONCE = ["ONCE", 3];
        displayEngineApi.TimingMode.ONCE.toString = $estr;
        displayEngineApi.TimingMode.ONCE.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.TimingMode.TIMEOUT = ["TIMEOUT", 1];
        displayEngineApi.TimingMode.TIMEOUT.toString = $estr;
        displayEngineApi.TimingMode.TIMEOUT.__enum__ = displayEngineApi.TimingMode;
        displayEngineApi.TimingMode.RAF = ["RAF", 0];
        displayEngineApi.TimingMode.RAF.toString = $estr;
        displayEngineApi.TimingMode.RAF.__enum__ = displayEngineApi.TimingMode;

        displayEngineApi.ICamera = function() {}
        displayEngineApi.ICamera.prototype = {

        };

        displayEngineApi.IMesh = function() {}
        displayEngineApi.IMesh.prototype = {

        };

        displayEngineApi.ICard = function() {}
        displayEngineApi.ICard.prototype = {

            get_display: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            get_renderShadow: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            set_renderShadow: function(value) {
                return {
                    arguments: ["boolean"],
                    returns: "boolean"
                };
            },
            get_shadowColor: function() {
                return {
                    arguments: [],
                    returns: "string"
                };
            },
            set_shadowColor: function(value) {
                return {
                    arguments: ["string"],
                    returns: "string"
                };
            },
            get_shadowBlur: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            set_shadowBlur: function(value) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            get_shadowOffsetX: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            set_shadowOffsetX: function(value) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            get_shadowOffsetY: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            set_shadowOffsetY: function(value) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            get_darken: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            set_darken: function(value) {
                return {
                    arguments: ["number"],
                    returns: "number"
                };
            },
            renderNormal: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            update: function(bmpBack, bmpFront) {
                return {
                    arguments: ["*", "*"],
                    returns: "void"
                };
            },
            flip: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getDisplayObject: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            dispose: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            getDrawOffset: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IColor4 = function() {}
        displayEngineApi.IColor4.prototype = {

            set: function(initialR, initialG, initialB, initialA) {
                return {
                    arguments: [{
                        type: "number",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IMatrix = function() {}
        displayEngineApi.IMatrix.prototype = {

            isIdentity: function() {
                return {
                    arguments: [],
                    returns: "boolean"
                };
            },
            determinant: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            toArray: function() {
                return {
                    arguments: [],
                    returns: "array"
                };
            },
            invert: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            multiply: function(other) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            equals: function(value) {
                return {
                    arguments: ["*"],
                    returns: "boolean"
                };
            }
        };

        displayEngineApi.IPlane = function() {}
        displayEngineApi.IPlane.prototype = {

            renderNormal: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IRenderer = function() {}
        displayEngineApi.IRenderer.prototype = {

            clear: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            putPixel: function(x, y, z, color) {
                return {
                    arguments: ["number", "number", "number", "*"],
                    returns: "void"
                };
            },
            drawPoint: function(point, color) {
                return {
                    arguments: ["*", "*"],
                    returns: "void"
                };
            },
            present: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            },
            clamp: function(value, min, max) {
                return {
                    arguments: ["number", {
                        type: "number",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "number"
                };
            },
            interpolate: function(min, max, gradient) {
                return {
                    arguments: ["number", "number", "number"],
                    returns: "number"
                };
            },
            project: function(vertex, transMat, world) {
                return {
                    arguments: ["*", "*", "*"],
                    returns: "null"
                };
            },
            computeNDotL: function(vertex, normal, lightPosition) {
                return {
                    arguments: ["*", "*", "*"],
                    returns: "number"
                };
            },
            processScanLine: function(data, va, vb, vc, vd, color, texture) {
                return {
                    arguments: ["*", "*", "*", "*", "*", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            drawTriangle: function(v1, v2, v3, color, texture) {
                return {
                    arguments: ["*", "*", "*", "*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            render: function(camera, meshes) {
                return {
                    arguments: ["*", "array"],
                    returns: "void"
                };
            }
        };

        displayEngineApi.ITexture = function() {}
        displayEngineApi.ITexture.prototype = {

            get_img: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            update: function(bmp) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            map: function(tu, tv) {
                return {
                    arguments: ["number", "number"],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IVector2 = function() {}
        displayEngineApi.IVector2.prototype = {

        };

        displayEngineApi.IVector3 = function() {}
        displayEngineApi.IVector3.prototype = {

            set: function(initialX, initialY, initialZ) {
                return {
                    arguments: [{
                        type: "number",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }, {
                        type: "number",
                        opt: true
                    }],
                    returns: "void"
                };
            },
            subtract: function(otherVector) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            subtractToRef: function(otherVector, ref) {
                return {
                    arguments: ["*", "*"],
                    returns: "void"
                };
            },
            add: function(otherVector) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            negate: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            equals: function(otherVector) {
                return {
                    arguments: ["*"],
                    returns: "boolean"
                };
            },
            multiply: function(otherVector) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            divide: function(otherVector) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            length: function() {
                return {
                    arguments: [],
                    returns: "number"
                };
            },
            normalize: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        displayEngineApi.IVector4 = function() {}
        displayEngineApi.IVector4.prototype = {

        };
        displayEngineApi.DisplayObjectEvents = function() {};
        displayEngineApi.DisplayObjectEvents.__name__ = ["displayEngineApi", "DisplayObjectEvents"];
        displayEngineApi.DisplayObjectEvents.prototype.__class__ = displayEngineApi.DisplayObjectEvents;
        displayEngineApi.MovieClipEvents = function() {};
        displayEngineApi.MovieClipEvents.__name__ = ["displayEngineApi", "MovieClipEvents"];
        displayEngineApi.MovieClipEvents.prototype.__class__ = displayEngineApi.MovieClipEvents;
        displayEngineApi.DisplayConstants = function() {};
        displayEngineApi.DisplayConstants.__name__ = ["displayEngineApi", "DisplayConstants"];
        displayEngineApi.DisplayConstants.prototype.__class__ = displayEngineApi.DisplayConstants;
        displayEngineApi.DisplayType = {
            __ename__: ["displayEngineApi", "DisplayType"],
            __constructs__: ["STAGE", "STAGE3D", "DISPLAY_OBJECT", "DISPLAY_OBJECT_CONTAINER", "MOVIE_CLIP", "GRAPHICS", "BITMAP", "SPRITE", "VIDEO"]
        };
        displayEngineApi.DisplayType.STAGE3D = ["STAGE3D", 1];
        displayEngineApi.DisplayType.STAGE3D.toString = $estr;
        displayEngineApi.DisplayType.STAGE3D.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.BITMAP = ["BITMAP", 6];
        displayEngineApi.DisplayType.BITMAP.toString = $estr;
        displayEngineApi.DisplayType.BITMAP.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.MOVIE_CLIP = ["MOVIE_CLIP", 4];
        displayEngineApi.DisplayType.MOVIE_CLIP.toString = $estr;
        displayEngineApi.DisplayType.MOVIE_CLIP.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.STAGE = ["STAGE", 0];
        displayEngineApi.DisplayType.STAGE.toString = $estr;
        displayEngineApi.DisplayType.STAGE.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.VIDEO = ["VIDEO", 8];
        displayEngineApi.DisplayType.VIDEO.toString = $estr;
        displayEngineApi.DisplayType.VIDEO.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.DISPLAY_OBJECT_CONTAINER = ["DISPLAY_OBJECT_CONTAINER", 3];
        displayEngineApi.DisplayType.DISPLAY_OBJECT_CONTAINER.toString = $estr;
        displayEngineApi.DisplayType.DISPLAY_OBJECT_CONTAINER.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.GRAPHICS = ["GRAPHICS", 5];
        displayEngineApi.DisplayType.GRAPHICS.toString = $estr;
        displayEngineApi.DisplayType.GRAPHICS.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.DISPLAY_OBJECT = ["DISPLAY_OBJECT", 2];
        displayEngineApi.DisplayType.DISPLAY_OBJECT.toString = $estr;
        displayEngineApi.DisplayType.DISPLAY_OBJECT.__enum__ = displayEngineApi.DisplayType;
        displayEngineApi.DisplayType.SPRITE = ["SPRITE", 7];
        displayEngineApi.DisplayType.SPRITE.toString = $estr;
        displayEngineApi.DisplayType.SPRITE.__enum__ = displayEngineApi.DisplayType;

        displayEngineApi.IDisplayProvider = function() {}
        displayEngineApi.IDisplayProvider.prototype = {

            getFactory: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getStages: function() {
                return {
                    arguments: [],
                    returns: Map
                };
            },
            getDefaultStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        displayEngineApi.IFactory = function() {}
        displayEngineApi.IFactory.prototype = {

            createStage: function(def) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            createStage3D: function(id, width, height, options) {
                return {
                    arguments: ["string", "number", "number", {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createDisplayObjectContainer: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            createMovieClip: function(def) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            },
            createCard3D: function(name, bmpBack, bmpFront, options, camera) {
                return {
                    arguments: ["string", "*", "*", {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createCamera: function(pos, tar) {
                return {
                    arguments: [{
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createOffscreenStage: function(width, height, isWebGL, timingMode, targetFPS) {
                return {
                    arguments: ["number", "number", {
                        type: "boolean",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }, {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createGraphics: function(cacheCommands) {
                return {
                    arguments: [{
                        type: "boolean",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createBitmap: function(image, offset) {
                return {
                    arguments: ["*", {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createBitmapText: function(text, options) {
                return {
                    arguments: ["string", {
                        type: "*",
                        opt: true
                    }],
                    returns: "*"
                };
            },
            createSprite: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            createParticleSystem: function(img, type, config) {
                return {
                    arguments: ["*", "string", "*"],
                    returns: "*"
                };
            },
            createAnimation: function(name, object, animDef) {
                return {
                    arguments: [{
                        type: "string",
                        opt: true
                    }, "*", "*"],
                    returns: "*"
                };
            },
            cache: function(objects) {
                return {
                    arguments: ["array"],
                    returns: "string"
                };
            },
            uncache: function(objectID) {
                return {
                    arguments: ["string"],
                    returns: "void"
                };
            }
        };
        displayEngineApi.MCDef = function(name, animeDef, animDefState, animationBitmap, offScreen, videoDef) {
            this.name = name;
            this.animeDef;
            this.animDefState = animDefState;
            this.animationBitmap = animationBitmap;
            this.videoDef = videoDef;
            this.offScreen = offScreen;
        };
        displayEngineApi.MCDef.__name__ = ["displayEngineApi", "MCDef"];
        displayEngineApi.MCDef.prototype.name = null;
        displayEngineApi.MCDef.prototype.animeDef = null;
        displayEngineApi.MCDef.prototype.animDefState = null;
        displayEngineApi.MCDef.prototype.animationBitmap = null;
        displayEngineApi.MCDef.prototype.offScreen = null;
        displayEngineApi.MCDef.prototype.videoDef = null;
        displayEngineApi.MCDef.prototype.__class__ = displayEngineApi.MCDef;
        displayEngineApi.Point = function(x, y) {
            this.x = x;
            this.y = y;
        };
        displayEngineApi.Point.__name__ = ["displayEngineApi", "Point"];
        displayEngineApi.Point.prototype.x = null;
        displayEngineApi.Point.prototype.y = null;
        displayEngineApi.Point.prototype.__class__ = displayEngineApi.Point;
        displayEngineApi.Rectangle = function(x, y, w, h) {
            this.x = x;
            this.y = y;
            this.w = w;
            this.h = h;
        };
        displayEngineApi.Rectangle.__name__ = ["displayEngineApi", "Rectangle"];
        displayEngineApi.Rectangle.prototype.x = null;
        displayEngineApi.Rectangle.prototype.y = null;
        displayEngineApi.Rectangle.prototype.w = null;
        displayEngineApi.Rectangle.prototype.h = null;
        displayEngineApi.Rectangle.prototype.__class__ = displayEngineApi.Rectangle;
        displayEngineApi.StageDef = function(id, dimension, canvas, isWebgl, timingMode, targetFPS) {
            if (targetFPS == null) targetFPS = 60;
            this.targetFPS = 60;
            this.id = id;
            this.dimension = dimension;
            this.canvas = canvas;
            this.isWebgl = isWebgl;
            if (timingMode != null) this.timingMode = timingMode;
            else this.timingMode = displayEngineApi.TimingMode.RAF;
            this.targetFPS = targetFPS;
        };
        displayEngineApi.StageDef.__name__ = ["displayEngineApi", "StageDef"];
        displayEngineApi.StageDef.prototype.id = null;
        displayEngineApi.StageDef.prototype.dimension = null;
        displayEngineApi.StageDef.prototype.canvas = null;
        displayEngineApi.StageDef.prototype.isWebgl = null;
        displayEngineApi.StageDef.prototype.timingMode = null;
        displayEngineApi.StageDef.prototype.targetFPS = null;
        displayEngineApi.StageDef.prototype.__class__ = displayEngineApi.StageDef;
        displayEngineApi.VideoDef = function(src, poster, width, height, framerate, autoPlay, loop) {};
        displayEngineApi.VideoDef.__name__ = ["displayEngineApi", "VideoDef"];
        displayEngineApi.VideoDef.prototype.src = null;
        displayEngineApi.VideoDef.prototype.poster = null;
        displayEngineApi.VideoDef.prototype.width = null;
        displayEngineApi.VideoDef.prototype.height = null;
        displayEngineApi.VideoDef.prototype.framerate = null;
        displayEngineApi.VideoDef.prototype.autoPlay = null;
        displayEngineApi.VideoDef.prototype.loop = null;
        displayEngineApi.VideoDef.prototype.__class__ = displayEngineApi.VideoDef;
        if (typeof haxe == 'undefined') {
            var haxe = {};
        };

        haxe.IMap = function() {}
        haxe.IMap.prototype = {

        };
        displayEngineApi.DisplayObjectEvents.ENTER_FRAME = "enterFrame";;
        displayEngineApi.DisplayObjectEvents.CLICK = "click";;
        displayEngineApi.DisplayObjectEvents.DOUBLE_CLICK = "doubleclick";;
        displayEngineApi.DisplayObjectEvents.MIDDLE_CLICK = "middleclick";;
        displayEngineApi.DisplayObjectEvents.MIDDLE_MOUSE_DOWN = "middlemousedown";;
        displayEngineApi.DisplayObjectEvents.MIDDLE_MOUSE_UP = "middlemouseup";;
        displayEngineApi.DisplayObjectEvents.MOUSE_DOWN = "mousedown";;
        displayEngineApi.DisplayObjectEvents.MOUSE_MOVE = "mousemove";;
        displayEngineApi.DisplayObjectEvents.MOUSE_OUT = "mouseout";;
        displayEngineApi.DisplayObjectEvents.MOUSE_OVER = "mouseover";;
        displayEngineApi.DisplayObjectEvents.MOUSE_UP = "mouseup";;
        displayEngineApi.DisplayObjectEvents.MOUSE_WHEEL = "DOMMouseScroll";;
        displayEngineApi.DisplayObjectEvents.RIGHT_CLICK = "rightclick";;
        displayEngineApi.DisplayObjectEvents.RIGHT_MOUSE_DOWN = "rightmousedown";;
        displayEngineApi.DisplayObjectEvents.RIGHT_MOUSE_UP = "rightmouseup";;
        displayEngineApi.DisplayObjectEvents.MOUSE_DRAG = "mousedrag";;
        displayEngineApi.DisplayObjectEvents.TOUCH_START = "touchstart";;
        displayEngineApi.DisplayObjectEvents.TOUCH_END = "touchend";;
        displayEngineApi.DisplayObjectEvents.TOUCH_MOVE = "touchmove";;
        displayEngineApi.DisplayObjectEvents.TOUCH_LEAVE = "touchleave";;
        displayEngineApi.DisplayObjectEvents.TOUCH_CANCEL = "touchcancel";;
        displayEngineApi.MovieClipEvents.ANIMATION_START = "mc_animationstart";;
        displayEngineApi.MovieClipEvents.ANIMATION_COMPLETE = "mc_animationcomplete";;
        displayEngineApi.MovieClipEvents.ANIMATION_TICK = "mc_animationtick";;
        displayEngineApi.DisplayConstants.DEFAULT_STAGE = "skgl_0";;
        displayEngineApi.DisplayConstants.DEFAULT_MC_STATE = "default";;
        return {
            exports: displayEngineApi
        };
    });