package webcamui {
    import flash.geom.*;
    import flash.display.*;
    import flash.utils.*;
    import __AS3__.vec.*;

    public class ColorUtils {

        public static function getBackgroundColor(_arg1:BitmapData):uint{
            var _local2:ByteArray = _arg1.getPixels(new Rectangle(0, 0, (_arg1.width / 10), (_arg1.height / 10)));
            var _local3:ByteArray = _arg1.getPixels(new Rectangle(((_arg1.width * 9) / 10), 0, (_arg1.width / 10), (_arg1.height / 10)));
            var _local4:uint;
            var _local5:uint;
            var _local6:uint;
            var _local7:uint;
            _local2.position = 0;
            while (_local2.bytesAvailable > 3) {
                _local7 = _local2.readUnsignedInt();
                _local4 = (_local4 + ((_local7 >> 16) & 0xFF));
                _local5 = (_local5 + ((_local7 >> 8) & 0xFF));
                _local6 = (_local6 + (_local7 & 0xFF));
            };
            _local3.position = 0;
            while (_local3.bytesAvailable > 3) {
                _local7 = _local3.readUnsignedInt();
                _local4 = (_local4 + ((_local7 >> 16) & 0xFF));
                _local5 = (_local5 + ((_local7 >> 8) & 0xFF));
                _local6 = (_local6 + (_local7 & 0xFF));
            };
            _local4 = uint((_local4 / ((_local2.length / 4) + (_local3.length / 4))));
            _local5 = uint((_local5 / ((_local2.length / 4) + (_local3.length / 4))));
            _local6 = uint((_local6 / ((_local2.length / 4) + (_local3.length / 4))));
            return ((((_local4 << 16) | (_local5 << 8)) | _local6));
        }
        public static function emptyPixel32(_arg1:uint, _arg2:Boolean):uint{
            if (_arg2){
                return (0);
            };
            return (_arg1);
        }
        public static function inRange(_arg1:Number, _arg2:Number, _arg3:Number):Boolean{
            if (_arg2 < _arg3){
                return ((((_arg1 <= _arg2)) || ((_arg1 >= _arg3))));
            };
            return ((((_arg1 <= _arg2)) && ((_arg1 >= _arg3))));
        }
        public static function rgbThreshold(_arg1:BitmapData, _arg2:BitmapData, _arg3:Rectangle, _arg4:Function, _arg5:Function):void{
            var _local15:int;
            var _local16:uint;
            var _local17:uint;
            var _local18:uint;
            var _local19:uint;
            _arg1.lock();
            var _local6:int = int(_arg3.x);
            var _local7:int = int(_arg3.y);
            var _local8:int = int(_arg3.width);
            var _local9:int = int(_arg3.height);
            var _local10:Function = _arg2.getPixel;
            var _local11:Boolean = _arg1.transparent;
            var _local12:Function = ((_local11) ? _arg1.getPixel32 : _arg1.getPixel);
            var _local13:Function = ((_local11) ? _arg1.setPixel32 : _arg1.setPixel);
            var _local14:int = _local6;
            while (_local14 < _local8) {
                _local15 = _local7;
                while (_local15 < _local9) {
                    _local16 = _local10(_local14, _local15);
                    _local17 = ((_local16 >> 16) & 0xFF);
                    _local18 = ((_local16 >> 8) & 0xFF);
                    _local19 = (_local16 & 0xFF);
                    _local13(_local14, _local15, _arg5(_local12(_local14, _local15), _arg4(_local17, _local18, _local19)));
                    _local15++;
                };
                _local14++;
            };
            _arg1.unlock();
        }
        public static function hslThreshold(_arg1:BitmapData, _arg2:BitmapData, _arg3:Rectangle, _arg4:Function, _arg5:Function):void{
            var _local7:uint;
            var _local8:Vector.<Number>;
            var _local9:Number;
            var _local10:Number;
            var _local11:Number;
            _arg1.lock();
            var _local6:uint = _arg3.x;
            while (_local6 < _arg3.width) {
                _local7 = _arg3.y;
                while (_local7 < _arg3.height) {
                    _local8 = rgbToHsl(_arg2.getPixel(_local6, _local7));
                    _local9 = _local8[0];
                    _local10 = _local8[1];
                    _local11 = _local8[2];
                    if (_arg1.transparent){
                        _arg1.setPixel32(_local6, _local7, _arg5(_arg1.getPixel32(_local6, _local7), _arg4(_local9, _local10, _local11)));
                    } else {
                        _arg1.setPixel(_local6, _local7, _arg5(_arg1.getPixel(_local6, _local7), _arg4(_local9, _local10, _local11)));
                    };
                    _local7++;
                };
                _local6++;
            };
            _arg1.unlock();
        }
        public static function rgbToComp(_arg1:uint):Vector.<uint>{
            return (new <uint>[((_arg1 >> 16) & 0xFF), ((_arg1 >> 8) & 0xFF), (_arg1 & 0xFF)]);
        }
        public static function rgbToHsl(_arg1:uint):Vector.<Number>{
            var _local10:Number;
            var _local2:Number = (Number(((_arg1 >> 16) & 0xFF)) / 0xFF);
            var _local3:Number = (Number(((_arg1 >> 8) & 0xFF)) / 0xFF);
            var _local4:Number = (Number((_arg1 & 0xFF)) / 0xFF);
            var _local5:Number = Math.max(_local2, _local3, _local4);
            var _local6:Number = Math.min(_local2, _local3, _local4);
            var _local7:Number = 0;
            var _local8:Number = 0;
            var _local9:Number = ((_local5 + _local6) / 2);
            if (_local5 != _local6){
                _local10 = (_local5 - _local6);
                _local8 = (((_local9 > 0.5)) ? (_local10 / ((2 - _local5) - _local6)) : (_local10 / (_local5 + _local6)));
                switch (_local5){
                    case _local2:
                        _local7 = (((_local3 - _local4) / _local10) + (((_local3 < _local4)) ? 6 : 0));
                        break;
                    case _local3:
                        _local7 = (((_local4 - _local2) / _local10) + 2);
                        break;
                    case _local4:
                        _local7 = (((_local2 - _local3) / _local10) + 4);
                        break;
                };
                _local7 = (_local7 * 60);
            };
            return (new <Number>[_local7, _local8, _local9]);
        }

    }
}//package webcamui 
package webcamui {
    import flash.geom.*;
    import flash.display.*;
    import uiwidgets.*;

    public class CheckBox extends IconButton {

        public function CheckBox(_arg1:Function){
            var _local2:Shape = new Shape();
            this.drawCheckBox(_local2.graphics, true);
            var _local3:Shape = new Shape();
            this.drawCheckBox(_local3.graphics, false);
            super(_arg1, _local2, _local3);
        }
        private function drawCheckBox(_arg1:Graphics, _arg2:Boolean):void{
            _arg1.lineStyle(1, 0, 1, true);
            var _local3:Matrix = new Matrix();
            _local3.createGradientBox(10, 10, 0, -5, -5);
            _arg1.beginGradientFill(GradientType.RADIAL, [0xFFFFFF, 0xCCCCCC], [1, 1], [0, 0xFF], _local3);
            _arg1.drawRect(0, 0, 10, 10);
            _arg1.endFill();
            if (_arg2){
                _arg1.lineStyle(2.5, 3355647, 1);
                _arg1.moveTo(2, 3);
                _arg1.lineTo(5, 9);
                _arg1.lineTo(10, 0);
            };
        }

    }
}//package webcamui 
package webcamui {
    import flash.geom.*;
    import flash.events.*;
    import flash.display.*;

    public class Slider extends Sprite {

        private var _maxValue:Number;
        private var _minValue:Number;
        private var _retValue:Number;
        private var _track:Sprite;
        private var _thumb:Sprite;

        public function Slider(_arg1:Number=100, _arg2:Number=0){
            this.maxValue = _arg1;
            this.minValue = _arg2;
            this._track = new Sprite();
            var _local3:Graphics = this._track.graphics;
            _local3.beginFill(0xAAAAAA);
            _local3.drawRect(0, 0, 100, 5);
            this._track.addEventListener(MouseEvent.MOUSE_DOWN, this.beginDrag, false, 0, true);
            addChild(this._track);
            this._thumb = new Sprite();
            _local3 = this._thumb.graphics;
            _local3.lineStyle(1, 0, 1, true);
            _local3.beginFill(0xCCCCCC);
            _local3.drawCircle(0, 0, 7.5);
            this._thumb.x = 100;
            this._thumb.y = 3.75;
            this._thumb.addEventListener(MouseEvent.MOUSE_DOWN, this.beginDrag, false, 0, true);
            addChild(this._thumb);
        }
        public function get maxValue():Number{
            return (this._maxValue);
        }
        public function set maxValue(_arg1:Number):void{
            this._maxValue = ((isFinite(_arg1)) ? _arg1 : this._maxValue);
        }
        public function get minValue():Number{
            return (this._minValue);
        }
        public function set minValue(_arg1:Number):void{
            this._minValue = ((isFinite(_arg1)) ? _arg1 : this._minValue);
        }
        public function get value():Number{
            return ((((this._thumb.x / 100) * (this.maxValue - this.minValue)) + this.minValue));
        }
        public function set value(_arg1:Number):void{
            if (((((isFinite(_arg1)) && ((_arg1 <= this.maxValue)))) && ((_arg1 >= this.minValue)))){
                this._thumb.x = (((_arg1 - this.minValue) / (this.maxValue - this.minValue)) * 100);
                dispatchEvent(new SliderEvent(SliderEvent.UPDATE));
            };
        }
        private function beginDrag(_arg1:MouseEvent):void{
            stage.addEventListener(MouseEvent.MOUSE_MOVE, this.doDrag, false, 0, true);
            stage.addEventListener(MouseEvent.MOUSE_UP, this.endDrag, false, 0, true);
            this._retValue = this.value;
            if (_arg1.target == this._track){
                this.doDrag(_arg1);
            };
        }
        private function doDrag(_arg1:MouseEvent):void{
            this.value = ((this._track.globalToLocal(new Point(_arg1.stageX, _arg1.stageY)).x / 100) * this.maxValue);
        }
        private function returnDrag(_arg1:MouseEvent):void{
            if (_arg1.target != this._thumb){
                this.value = this._retValue;
                stage.removeEventListener(MouseEvent.MOUSE_MOVE, this.doDrag);
                stage.removeEventListener(MouseEvent.MOUSE_UP, this.returnDrag);
            };
        }
        private function endDrag(_arg1:MouseEvent):void{
            this.doDrag(_arg1);
            stage.removeEventListener(MouseEvent.MOUSE_MOVE, this.doDrag);
            stage.removeEventListener(MouseEvent.MOUSE_UP, this.endDrag);
            dispatchEvent(new SliderEvent(SliderEvent.UPDATE));
        }

    }
}//package webcamui 
package webcamui {

    public class WebCamPaneState {

        public static const CAMERA:String = "camera";
        public static const PICTURE:String = "picture";

    }
}//package webcamui 
package webcamui.inspirit {
    import mx.core.*;

    public class InspiritCannyEdgeDetector_Gray extends ByteArrayAsset {

    }
}//package webcamui.inspirit 
package webcamui.inspirit {
    import mx.core.*;

    public class InspiritCannyEdgeDetector_EdgeDiff extends ByteArrayAsset {

    }
}//package webcamui.inspirit 
package webcamui.inspirit {
    import mx.core.*;

    public class InspiritCannyEdgeDetector_Hysteresis extends ByteArrayAsset {

    }
}//package webcamui.inspirit 
package webcamui.inspirit {
    import mx.core.*;

    public class InspiritCannyEdgeDetector_BytesToBitmap extends ByteArrayAsset {

    }
}//package webcamui.inspirit 
package webcamui.inspirit {
    import mx.core.*;

    public class InspiritCannyEdgeDetector_EdgeMagnitude extends ByteArrayAsset {

    }
}//package webcamui.inspirit 
package webcamui.inspirit {
    import mx.core.*;

    public class InspiritCannyEdgeDetector_GaussBlur extends ByteArrayAsset {

    }
}//package webcamui.inspirit 
package webcamui.inspirit {
    import flash.geom.*;
    import flash.display.*;
    import flash.utils.*;
    import __AS3__.vec.*;

    public final class InspiritCannyEdgeDetector {

        private var Gray:Class;
        private var GaussBlur:Class;
        private var EdgeDiff:Class;
        private var EdgeMagnitude:Class;
        private var BytesToBitmap:Class;
        private var Hysteresis:Class;
        protected var Gray_shader:Shader;
        protected var Gray_job:ShaderJob;
        protected var GaussBlur_shader:Shader;
        protected var GaussBlur_job:ShaderJob;
        protected var EdgeDiff_shader:Shader;
        protected var EdgeDiff_job:ShaderJob;
        protected var EdgeMagnitude_shader:Shader;
        protected var EdgeMagnitude_job:ShaderJob;
        protected var BytesToBitmap_shader:Shader;
        protected var BytesToBitmap_job:ShaderJob;
        protected var Hysteresis_shader:Shader;
        protected var Hysteresis_job:ShaderJob;
        protected var imgGrayResult:ByteArray;
        protected var imgBlurResult:ByteArray;
        protected var edgeDiffResult:ByteArray;
        protected var edgeMagResult:ByteArray;
        protected var image:BitmapData;
        protected var dataBmd:BitmapData;
        protected var width:int;
        protected var height:int;
        protected var size:int;
        protected var rect:Rectangle;
        protected var _lowThreshold:Number;
        protected var _highThreshold:Number;
        public var data:Vector.<uint>;
        public var magnitude:Vector.<uint>;

        public function InspiritCannyEdgeDetector(_arg1:BitmapData, _arg2:Number=0.01, _arg3:Number=0.1){
            this.Gray = InspiritCannyEdgeDetector_Gray;
            this.GaussBlur = InspiritCannyEdgeDetector_GaussBlur;
            this.EdgeDiff = InspiritCannyEdgeDetector_EdgeDiff;
            this.EdgeMagnitude = InspiritCannyEdgeDetector_EdgeMagnitude;
            this.BytesToBitmap = InspiritCannyEdgeDetector_BytesToBitmap;
            this.Hysteresis = InspiritCannyEdgeDetector_Hysteresis;
            super();
            this.image = _arg1;
            this.width = _arg1.width;
            this.height = _arg1.height;
            this.size = (this.width * this.height);
            this.rect = new Rectangle(0, 0, this.width, this.height);
            this._highThreshold = _arg3;
            this._lowThreshold = _arg2;
            this.data = new Vector.<uint>(this.size, true);
            this.dataBmd = new BitmapData(this.width, this.height, false, 0);
            this.dataBmd.lock();
            this.initShaders();
            this.initKernels();
        }
        public function detectEdges(_arg1:BitmapData):void{
            var _local3:uint;
            var _local8:int;
            this.Gray_job = new ShaderJob(this.Gray_shader, this.imgGrayResult, this.width, this.height);
            this.Gray_job.start(true);
            this.GaussBlur_job = new ShaderJob(this.GaussBlur_shader, this.imgBlurResult, this.width, this.height);
            this.GaussBlur_job.start(true);
            this.EdgeDiff_job = new ShaderJob(this.EdgeDiff_shader, this.edgeDiffResult, this.width, this.height);
            this.EdgeDiff_job.start(true);
            this.EdgeMagnitude_job = new ShaderJob(this.EdgeMagnitude_shader, this.edgeMagResult, this.width, this.height);
            this.EdgeMagnitude_job.start(true);
            this.BytesToBitmap_job = new ShaderJob(this.BytesToBitmap_shader, this.dataBmd, this.width, this.height);
            this.BytesToBitmap_job.start(true);
            this.magnitude = this.dataBmd.getVector(this.rect);
            var _local2:uint;
            var _local4:int = this.size;
            while (--_local4 > -1) {
                this.data[_local4] = 0;
                _local3 = (this.magnitude[_local4] & 0xFF);
                this.magnitude[_local4] = _local3;
                if (_local3 > _local2){
                    _local2 = _local3;
                };
            };
            var _local5:int = (_local2 * this._lowThreshold);
            var _local6:int = (_local2 * this._highThreshold);
            if (_local5 < 1){
                _local5 = 1;
            };
            if (_local6 < 1){
                _local6 = 1;
            };
            _local4 = 0;
            var _local7:int;
            while (_local7 < this.height) {
                _local8 = 0;
                while (_local8 < this.width) {
                    if ((((this.data[_local4] == 0)) && ((this.magnitude[_local4] >= _local6)))){
                        this.hysteresisFollow(this.data, this.magnitude, this.width, this.height, _local8, _local7, _local4, _local5);
                    };
                    _local8++;
                    _local4++;
                };
                _local7++;
            };
            _arg1.lock();
            _arg1.setVector(this.rect, this.data);
            _arg1.unlock();
        }
        public function detectEdgesBold(_arg1:BitmapData):void{
            this.Gray_job = new ShaderJob(this.Gray_shader, this.imgGrayResult, this.width, this.height);
            this.Gray_job.start(true);
            this.GaussBlur_job = new ShaderJob(this.GaussBlur_shader, this.imgBlurResult, this.width, this.height);
            this.GaussBlur_job.start(true);
            this.EdgeDiff_job = new ShaderJob(this.EdgeDiff_shader, this.edgeDiffResult, this.width, this.height);
            this.EdgeDiff_job.start(true);
            this.EdgeMagnitude_job = new ShaderJob(this.EdgeMagnitude_shader, this.edgeMagResult, this.width, this.height);
            this.EdgeMagnitude_job.start(true);
            _arg1.lock();
            this.Hysteresis_job = new ShaderJob(this.Hysteresis_shader, _arg1, this.width, this.height);
            this.Hysteresis_job.start(true);
            _arg1.unlock();
        }
        public function set lowThreshold(_arg1:Number):void{
            this._lowThreshold = _arg1;
            if (this._lowThreshold > this._highThreshold){
                _arg1 = this._lowThreshold;
                this._lowThreshold = this._highThreshold;
                this._highThreshold = _arg1;
            };
            this.Hysteresis_shader.data.low.value = [this._lowThreshold];
            this.Hysteresis_shader.data.high.value = [this._highThreshold];
        }
        public function set highThreshold(_arg1:Number):void{
            this._highThreshold = _arg1;
            if (this._lowThreshold > this._highThreshold){
                _arg1 = this._lowThreshold;
                this._lowThreshold = this._highThreshold;
                this._highThreshold = _arg1;
            };
            this.Hysteresis_shader.data.low.value = [this._lowThreshold];
            this.Hysteresis_shader.data.high.value = [this._highThreshold];
        }
        public function get lowThreshold():Number{
            return (this._lowThreshold);
        }
        public function get highThreshold():Number{
            return (this._highThreshold);
        }
        protected function hysteresisFollow(_arg1:Vector.<uint>, _arg2:Vector.<uint>, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int, _arg8:int):void{
            var _local13:int;
            var _local14:int;
            var _local15:int;
            var _local9:int = (((_arg5 == 0)) ? _arg5 : (_arg5 - 1));
            var _local10:int = (((_arg5 == (_arg3 - 1))) ? _arg5 : (_arg5 + 1));
            var _local11:int = (((_arg6 == 0)) ? _arg6 : (_arg6 - 1));
            var _local12:int = (((_arg6 == (_arg4 - 1))) ? _arg6 : (_arg6 + 1));
            _arg1[_arg7] = 0xFFFFFF;
            _local15 = _local11;
            while (_local15 <= _local12) {
                _local13 = int((_local9 + (_local15 * _arg3)));
                _local14 = _local9;
                while (_local14 <= _local10) {
                    if (((((((!((_local15 == _arg6))) || (!((_local14 == _arg5))))) && ((_arg1[_local13] == 0)))) && ((_arg2[_local13] >= _arg8)))){
                        this.hysteresisFollow(_arg1, _arg2, _arg3, _arg4, _local14, _local15, _local13, _arg8);
                        return;
                    };
                    _local14++;
                    _local13++;
                };
                _local15++;
            };
        }
        protected function initShaders():void{
            this.imgGrayResult = new ByteArray();
            this.imgBlurResult = new ByteArray();
            this.edgeDiffResult = new ByteArray();
            this.edgeMagResult = new ByteArray();
            this.imgGrayResult.endian = (this.imgBlurResult.endian = (this.edgeDiffResult.endian = (this.edgeMagResult.endian = Endian.LITTLE_ENDIAN)));
            this.Gray_shader = new Shader((new this.Gray() as ByteArray));
            this.Gray_shader.data.src.width = this.width;
            this.Gray_shader.data.src.height = this.height;
            this.Gray_shader.data.src.input = this.image;
            this.GaussBlur_shader = new Shader((new this.GaussBlur() as ByteArray));
            this.GaussBlur_shader.data.src.width = this.width;
            this.GaussBlur_shader.data.src.height = this.height;
            this.GaussBlur_shader.data.src.input = this.imgGrayResult;
            this.EdgeDiff_shader = new Shader((new this.EdgeDiff() as ByteArray));
            this.EdgeDiff_shader.data.src.width = this.width;
            this.EdgeDiff_shader.data.src.height = this.height;
            this.EdgeDiff_shader.data.src.input = this.imgBlurResult;
            this.EdgeMagnitude_shader = new Shader((new this.EdgeMagnitude() as ByteArray));
            this.EdgeMagnitude_shader.data.src.width = this.width;
            this.EdgeMagnitude_shader.data.src.height = this.height;
            this.EdgeMagnitude_shader.data.src.input = this.edgeDiffResult;
            this.BytesToBitmap_shader = new Shader((new this.BytesToBitmap() as ByteArray));
            this.BytesToBitmap_shader.data.src.width = this.width;
            this.BytesToBitmap_shader.data.src.height = this.height;
            this.BytesToBitmap_shader.data.src.input = this.edgeMagResult;
            this.Hysteresis_shader = new Shader((new this.Hysteresis() as ByteArray));
            this.Hysteresis_shader.data.src.width = this.width;
            this.Hysteresis_shader.data.src.height = this.height;
            this.Hysteresis_shader.data.src.input = this.edgeMagResult;
        }
        protected function initKernels(_arg1:Number=2, _arg2:int=10):void{
            var _local6:int;
            var _local7:Number;
            var _local8:Number;
            var _local9:Number;
            var _local3:Number = 0.005;
            var _local4:Vector.<Number> = new Vector.<Number>(_arg2, true);
            var _local5:Vector.<Number> = new Vector.<Number>(_arg2, true);
            _local6 = 0;
            while (_local6 < _arg2) {
                _local7 = this.gaussian(_local6, _arg1);
                if ((((_local7 <= _local3)) && ((_local6 >= 2)))){
                    break;
                };
                _local8 = this.gaussian((_local6 - 0.5), _arg1);
                _local9 = this.gaussian((_local6 + 0.5), _arg1);
                _local4[_local6] = ((((_local7 + _local8) + _local9) / 3) / ((6.283185 * _arg1) * _arg1));
                _local5[_local6] = (_local9 - _local8);
                _local6++;
            };
            this.GaussBlur_shader.data.weight0.value = [_local4[0]];
            this.GaussBlur_shader.data.weight1.value = [_local4[1]];
            this.GaussBlur_shader.data.weight2.value = [_local4[2]];
            this.GaussBlur_shader.data.weight3.value = [_local4[3]];
            this.GaussBlur_shader.data.weight4.value = [_local4[4]];
            this.GaussBlur_shader.data.weight5.value = [_local4[5]];
            this.GaussBlur_shader.data.weight6.value = [_local4[6]];
            this.EdgeDiff_shader.data.weight1.value = [_local5[1]];
            this.EdgeDiff_shader.data.weight2.value = [_local5[2]];
            this.EdgeDiff_shader.data.weight3.value = [_local5[3]];
            this.EdgeDiff_shader.data.weight4.value = [_local5[4]];
            this.EdgeDiff_shader.data.weight5.value = [_local5[5]];
            this.EdgeDiff_shader.data.weight6.value = [_local5[6]];
        }
        protected function gaussian(_arg1:Number, _arg2:Number):Number{
            return (Math.exp((-((_arg1 * _arg1)) / ((2 * _arg2) * _arg2))));
        }

    }
}//package webcamui.inspirit 
package webcamui {
    import flash.geom.*;
    import flash.display.*;
    import uiwidgets.*;
    import flash.utils.*;
    import flash.text.*;
    import __AS3__.vec.*;
    import flash.media.*;
    import flash.filters.*;
    import translation.*;
    import webcamui.inspirit.*;
    import assets.*;

    public class WebCamPane extends DialogBox {

        private var RGBThresholdFilter:Class;
        private var _rgbShader:Shader;
        private var _rgbShaderFilter:ShaderFilter;
        private var _cameraButton:CameraButton;
        private var _cloneBitmap:Bitmap;
        private var _container:Sprite;
        private var _picture:Bitmap;
        private var _pictureContainer:Sprite;
        private var _originalData:BitmapData;
        private var _rect:Rectangle;
        private var _state:String;
        private var _video:Video;
        private var _checkBox:CheckBox;
        private var _label:TextField;
        private var _slider:Slider;
        private var _edgeDetector:InspiritCannyEdgeDetector;
        private var _saveFunc:Function;
        private var _saveButton:Button;
        private var _closeButton:Button;

        public function WebCamPane(_arg1:Function){
            this.RGBThresholdFilter = WebCamPane_RGBThresholdFilter;
            super();
            this._saveFunc = _arg1;
            addTitle(Translator.map("Camera"));
            this._container = new Sprite();
            addWidget(this._container);
            this._pictureContainer = new Sprite();
            this._container.addChild(this._pictureContainer);
            this._picture = new Bitmap();
            this._picture.bitmapData = new BitmapData(320, 240, true);
            this._picture.visible = false;
            this._pictureContainer.addChild(this._picture);
            this._cloneBitmap = new Bitmap();
            this._cloneBitmap.blendMode = BlendMode.ALPHA;
            this._pictureContainer.addChild(this._cloneBitmap);
            this._rect = new Rectangle(0, 0, this._picture.bitmapData.width, this._picture.bitmapData.height);
            this._video = new Video(320, 240);
            this._video.smoothing = true;
            this._video.attachCamera(Camera.getCamera());
            this._container.addChild(this._video);
            this._checkBox = new CheckBox(this.toggleBackground);
            this._checkBox.x = 10;
            this._checkBox.y = 245;
            this._checkBox.visible = false;
            var _local2:TextFormat = new TextFormat(CSS.font, 10, 0, true);
            this._label = Resources.makeLabel(Translator.map("Remove Background"), _local2);
            this._label.x = 25;
            this._label.y = 250;
            this._label.visible = false;
            this._slider = new Slider(0.33, 0.02);
            this._slider.x = 10;
            this._slider.y = 265;
            this._slider.visible = false;
            this._slider.value = 0.3;
            this._slider.addEventListener(SliderEvent.UPDATE, this.updateBackground, false, 0, true);
            this._saveButton = new Button(Translator.map("Save"), this.savePicture);
            addChild(this._saveButton);
            buttons.push(this._saveButton);
            this._closeButton = new Button(Translator.map("Close"), this.closeDialog);
            addChild(this._closeButton);
            buttons.push(this._closeButton);
            this._rgbShader = new Shader((new this.RGBThresholdFilter() as ByteArray));
            this._rgbShaderFilter = new ShaderFilter(this._rgbShader);
        }
        public static function strings():Array{
            return (["Camera", "Save", "Close"]);
        }

        public function get picture():BitmapData{
            return (this._picture.bitmapData);
        }
        public function get rect():Rectangle{
            return (this._rect);
        }
        public function get state():String{
            return (this._state);
        }
        public function set state(_arg1:String):void{
            this._state = _arg1;
            switch (this.state){
                case WebCamPaneState.CAMERA:
                    this._picture.visible = false;
                    this._video.visible = true;
                    this._checkBox.visible = false;
                    this._label.visible = false;
                    this._slider.visible = false;
                    break;
                case WebCamPaneState.PICTURE:
                    this._video.visible = false;
                    this._picture.visible = true;
                    this._checkBox.visible = true;
                    this._label.visible = true;
                    this._slider.visible = true;
                    break;
            };
        }
        private function savePicture():void{
            this._picture.bitmapData.draw(this._video);
            if (this._saveFunc != null){
                this._saveFunc(this._picture.bitmapData.clone());
            };
        }
        public function closeDialog():void{
            if (this._video){
                this._video.attachCamera(null);
            };
            if (parent){
                parent.removeChild(this);
            };
        }
        private function showCamera():void{
            this.state = WebCamPaneState.CAMERA;
        }
        private function takePicture():void{
            this._picture.bitmapData.draw(this._video);
            this._originalData = this._picture.bitmapData.clone();
            this._checkBox.turnOff();
            this._slider.value = 6;
            this.state = WebCamPaneState.PICTURE;
        }
        private function updateBackground(_arg1:SliderEvent):void{
            if (this._checkBox.isOn()){
                this.toggleBackground(this._checkBox);
            };
        }
        private function toggleBackground(_arg1:IconButton):void{
            this._picture.bitmapData = this._originalData.clone();
            if (_arg1.isOn()){
                this.threshold8();
            };
        }
        private function threshold0():void{
            var _local1:uint = ColorUtils.getBackgroundColor(this._originalData);
            var _local2:uint = 0xC0C0C0;
            this._picture.bitmapData.threshold(this._originalData, this.rect, new Point(0, 0), "==", _local1, 0, _local2, true);
        }
        private function theshold1():void{
            var maxH:* = NaN;
            var minH:* = NaN;
            var maxS:* = NaN;
            var minS:* = NaN;
            var maxL:* = NaN;
            var minL:* = NaN;
            var hsl:* = ColorUtils.rgbToHsl(ColorUtils.getBackgroundColor(this._originalData));
            var range:* = 25;
            var hMult:* = 1;
            var sMult:* = 0.01;
            var lMult:* = 0.01;
            maxH = (hsl[0] + (range * hMult));
            maxH = (maxH - (((maxH > 360)) ? 360 : 0));
            minH = (hsl[0] - (range * hMult));
            minH = (minH + (((minH < 0)) ? 360 : 0));
            maxS = (hsl[1] + (range * sMult));
            minS = (hsl[1] - (range * sMult));
            maxL = (hsl[2] + (range * lMult));
            minL = (hsl[2] - (range * lMult));
            var threshold:* = function (_arg1:Number, _arg2:Number, _arg3:Number):Boolean{
                return (((((ColorUtils.inRange(_arg1, maxH, minH)) && (ColorUtils.inRange(_arg2, maxS, minS)))) && (ColorUtils.inRange(_arg3, maxL, minL))));
            };
            ColorUtils.hslThreshold(this._picture.bitmapData, this._picture.bitmapData, this.rect, threshold, ColorUtils.emptyPixel32);
        }
        private function threshold2():void{
            var maxR:* = NaN;
            var minR:* = NaN;
            var maxG:* = NaN;
            var minG:* = NaN;
            var maxB:* = NaN;
            var minB:* = NaN;
            var maxH:* = NaN;
            var minH:* = NaN;
            var rgbRaw:* = ColorUtils.getBackgroundColor(this._originalData);
            var rgb:* = ColorUtils.rgbToComp(rgbRaw);
            var range:* = (0xFF / this._slider.value);
            maxR = (rgb[0] + range);
            minR = (rgb[0] - range);
            maxG = (rgb[1] + range);
            minG = (rgb[1] - range);
            maxB = (rgb[2] + range);
            minB = (rgb[2] - range);
            var hsl:* = ColorUtils.rgbToHsl(rgbRaw);
            var hslRange:* = 20;
            var hMult:* = 1;
            maxH = (hsl[0] + (hslRange * hMult));
            maxH = (maxH - (((maxH > 360)) ? 360 : 0));
            minH = (hsl[0] - (hslRange * hMult));
            minH = (minH + (((minH < 0)) ? 360 : 0));
            var threshold:* = function (_arg1:Number, _arg2:Number, _arg3:Number):Boolean{
                var _local4:Boolean = ((((ColorUtils.inRange(_arg1, maxR, minR)) && (ColorUtils.inRange(_arg2, maxG, minG)))) && (ColorUtils.inRange(_arg3, maxB, minB)));
                var _local5:uint = (((_arg1 << 16) | (_arg2 << 8)) | _arg3);
                var _local6:Vector.<Number> = ColorUtils.rgbToHsl(_local5);
                return (((_local4) && (ColorUtils.inRange(_local6[0], maxH, minH))));
            };
            ColorUtils.rgbThreshold(this._picture.bitmapData, this._picture.bitmapData, this.rect, threshold, ColorUtils.emptyPixel32);
        }
        private function threshold3():void{
            var maxH:* = NaN;
            var minH:* = NaN;
            var maxS:* = NaN;
            var minS:* = NaN;
            var maxL:* = NaN;
            var minL:* = NaN;
            var blur:* = 8;
            var filter:* = new BlurFilter(blur, blur, BitmapFilterQuality.HIGH);
            var rect:* = new Rectangle(0, 0, this._picture.bitmapData.width, this._picture.bitmapData.height);
            var clone:* = this._picture.bitmapData.clone();
            clone.applyFilter(this._picture.bitmapData, rect, new Point(0, 0), filter);
            var hsl:* = ColorUtils.rgbToHsl(ColorUtils.getBackgroundColor(this._originalData));
            var range:* = 40;
            var hMult:* = 1;
            var sMult:* = 0.01;
            var lMult:* = 0.01;
            maxH = (hsl[0] + (range * hMult));
            maxH = (maxH - (((maxH > 360)) ? 360 : 0));
            minH = (hsl[0] - (range * hMult));
            minH = (minH + (((minH < 0)) ? 360 : 0));
            maxS = (hsl[1] + (range * sMult));
            minS = (hsl[1] - (range * sMult));
            maxL = (hsl[2] + (range * lMult));
            minL = (hsl[2] - (range * lMult));
            var threshold:* = function (_arg1:Number, _arg2:Number, _arg3:Number):Boolean{
                return (((((ColorUtils.inRange(_arg1, maxH, minH)) && (ColorUtils.inRange(_arg2, maxS, minS)))) && (ColorUtils.inRange(_arg3, maxL, minL))));
            };
            ColorUtils.hslThreshold(this._picture.bitmapData, clone, rect, threshold, ColorUtils.emptyPixel32);
        }
        private function threshold4():void{
            var rgb:* = null;
            var distance:* = 0;
            rgb = ColorUtils.rgbToComp(ColorUtils.getBackgroundColor(this._originalData));
            distance = 75;
            var threshold:* = function (_arg1:uint, _arg2:uint, _arg3:uint):Boolean{
                return ((((Math.abs((rgb[0] - _arg1)) + Math.abs((rgb[1] - _arg2))) + Math.abs((rgb[2] - _arg3))) <= distance));
            };
            ColorUtils.rgbThreshold(this._picture.bitmapData, this._picture.bitmapData, this.rect, threshold, ColorUtils.emptyPixel32);
        }
        private function threshold5():void{
            var maxR:* = NaN;
            var minR:* = NaN;
            var maxG:* = NaN;
            var minG:* = NaN;
            var maxB:* = NaN;
            var minB:* = NaN;
            var rgb:* = ColorUtils.rgbToComp(ColorUtils.getBackgroundColor(this._originalData));
            var range:* = this._slider.value;
            maxR = (rgb[0] + range);
            minR = (rgb[0] - range);
            maxG = (rgb[1] + range);
            minG = (rgb[1] - range);
            maxB = (rgb[2] + range);
            minB = (rgb[2] - range);
            var threshold:* = function (_arg1:uint, _arg2:uint, _arg3:uint):Boolean{
                return (((((ColorUtils.inRange(_arg1, maxR, minR)) && (ColorUtils.inRange(_arg2, maxG, minG)))) && (ColorUtils.inRange(_arg3, maxB, minB))));
            };
            var clone:* = this._originalData.clone();
            this._cloneBitmap.bitmapData = clone;
            var makeAlmostOpaque:* = function (_arg1:uint, _arg2:Boolean):uint{
                if (_arg2){
                    return (0xFE000000);
                };
                return (_arg1);
            };
            ColorUtils.rgbThreshold(clone, clone, this.rect, threshold, makeAlmostOpaque);
            var picWidth:* = this._picture.bitmapData.width;
            clone.floodFill(0, 0, 0);
            clone.floodFill(picWidth, 0, 0);
            this._picture.bitmapData.draw(this._pictureContainer);
            clone.dispose();
        }
        private function threshold6():void{
            var _local1:Vector.<uint> = ColorUtils.rgbToComp(ColorUtils.getBackgroundColor(this._originalData));
            var _local2:Number = _local1[0];
            var _local3:Number = _local1[1];
            var _local4:Number = _local1[2];
            var _local5:Number = this._slider.value;
            var _local6:Number = Math.min(1, ((_local2 + _local5) / 0xFF));
            var _local7:Number = Math.max(0, ((_local2 - _local5) / 0xFF));
            var _local8:Number = Math.min(1, ((_local3 + _local5) / 0xFF));
            var _local9:Number = Math.max(0, ((_local3 - _local5) / 0xFF));
            var _local10:Number = Math.min(1, ((_local4 + _local5) / 0xFF));
            var _local11:Number = Math.max(0, ((_local4 - _local5) / 0xFF));
            this._rgbShader.data.upperLimit.value = [_local6, _local8, _local10];
            this._rgbShader.data.lowerLimit.value = [_local7, _local9, _local11];
            this._rgbShader.data.replacement.value = [0, 0, 0, (254 / 0xFF)];
            var _local12:BitmapData = this._originalData.clone();
            this._cloneBitmap.bitmapData = _local12;
            _local12.applyFilter(this._originalData, this.rect, new Point(0, 0), this._rgbShaderFilter);
            var _local13:int = this._picture.bitmapData.width;
            _local12.floodFill(0, 0, 0);
            _local12.floodFill(_local13, 0, 0);
            this._picture.bitmapData.draw(this._pictureContainer);
            _local12.dispose();
        }
        private function threshold7():void{
            var maxH:* = NaN;
            var minH:* = NaN;
            var maxS:* = NaN;
            var minS:* = NaN;
            var maxL:* = NaN;
            var minL:* = NaN;
            var hsl:* = ColorUtils.rgbToHsl(ColorUtils.getBackgroundColor(this._originalData));
            var range:* = this._slider.value;
            var hMult:* = 1;
            var sMult:* = 0.01;
            var lMult:* = 0.01;
            maxH = (hsl[0] + (range * hMult));
            maxH = (maxH - (((maxH > 360)) ? 360 : 0));
            minH = (hsl[0] - (range * hMult));
            minH = (minH + (((minH < 0)) ? 360 : 0));
            maxS = (hsl[1] + 0.2);
            minS = (hsl[1] - 0.2);
            maxL = (hsl[2] + 0.4);
            minL = (hsl[2] - 0.4);
            var threshold:* = function (_arg1:Number, _arg2:Number, _arg3:Number):Boolean{
                return (((((ColorUtils.inRange(_arg1, maxH, minH)) && (ColorUtils.inRange(_arg2, maxS, minS)))) && (ColorUtils.inRange(_arg3, maxL, minL))));
            };
            var clone:* = this._originalData.clone();
            this._cloneBitmap.bitmapData = clone;
            var makeAlmostOpaque:* = function (_arg1:uint, _arg2:Boolean):uint{
                if (_arg2){
                    return (0xFE000000);
                };
                return (_arg1);
            };
            ColorUtils.hslThreshold(clone, clone, this.rect, threshold, makeAlmostOpaque);
            var picWidth:* = this._picture.bitmapData.width;
            clone.floodFill(0, 0, 0);
            clone.floodFill(picWidth, 0, 0);
            this._picture.bitmapData.draw(this._pictureContainer);
            clone.dispose();
        }
        private function threshold8():void{
            var _local1:BitmapData = this._originalData.clone();
            this._cloneBitmap.bitmapData = _local1;
            this._edgeDetector = new InspiritCannyEdgeDetector(_local1, 0.02, this._slider.value);
            var _local2:int = this._picture.bitmapData.width;
            this._edgeDetector.detectEdgesBold(_local1);
            _local1.floodFill(0, 0, 0);
            _local1.floodFill(_local2, 0, 0);
            this._picture.bitmapData.draw(this._pictureContainer);
            _local1.dispose();
        }

    }
}//package webcamui 
package webcamui {
    import flash.events.*;

    public class SliderEvent extends Event {

        public static const UPDATE:String = "update";

        public function SliderEvent(_arg1:String){
            super(_arg1);
        }
    }
}//package webcamui 
package webcamui {
    import mx.core.*;

    public class WebCamPane_RGBThresholdFilter extends ByteArrayAsset {

    }
}//package webcamui 
package webcamui {
    import flash.display.*;
    import uiwidgets.*;

    public class CameraButton extends Button {

        private var _cameraIcon:Shape;
        private var _readyFunc:Function;
        private var _notReadyFunc:Function;
        private var _ready:Boolean;

        public function CameraButton(_arg1:Function, _arg2:Function){
            super("Take Picture", this.triggerClick);
            this._readyFunc = _arg1;
            this._notReadyFunc = _arg2;
            this._cameraIcon = new Shape();
            this.drawCamera(this._cameraIcon.graphics);
            setIcon(this._cameraIcon);
            this.ready = true;
        }
        public function get ready():Boolean{
            return (this._ready);
        }
        private function set ready(_arg1:Boolean):void{
            this._ready = _arg1;
            if (this._ready){
                setIcon(this._cameraIcon);
            } else {
                setLabel("Redo");
            };
        }
        private function drawCamera(_arg1:Graphics):void{
            _arg1.lineStyle(0, 0, 0);
            _arg1.beginFill(0, 0);
            _arg1.drawRect(0, 0, 40, 10);
            _arg1.beginFill(3355545);
            _arg1.drawRoundRect(7.5, 0, 25, 10, 10, 25);
            _arg1.beginFill(0x999999);
            _arg1.drawCircle(20, 5, 4);
            _arg1.beginFill(0xFFFFFF);
            _arg1.drawCircle(20, 5, 3);
        }
        private function triggerClick():void{
            if (this.ready){
                this._readyFunc();
            } else {
                this._notReadyFunc();
            };
            this.ready = !(this.ready);
        }

    }
}//package webcamui 
package soundbank {
    import mx.core.*;

    public class Instr_BassTrombone_A2_2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_As3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Marimba_C4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_C6 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_WoodBlock extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Bassoon_C3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AltoSax_C6 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SynthLead_C6 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Flute_B5_1 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_D7 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_ElectricPiano_C2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Trombone_B3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SynthLead_C4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SynthPad_C6 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SynthPad_A3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Triangle extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Cabasa extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_TenorSax_C3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Flute_B5_2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Pizz_E4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import flash.utils.*;
    import sound.*;

    public class Instr {

        public static const AcousticGuitar_F3:Class = Instr_AcousticGuitar_F3;
        public static const AcousticPiano_As3:Class = Instr_AcousticPiano_As3;
        public static const AcousticPiano_C4:Class = Instr_AcousticPiano_C4;
        public static const AcousticPiano_G4:Class = Instr_AcousticPiano_G4;
        public static const AcousticPiano_F5:Class = Instr_AcousticPiano_F5;
        public static const AcousticPiano_C6:Class = Instr_AcousticPiano_C6;
        public static const AcousticPiano_Ds6:Class = Instr_AcousticPiano_Ds6;
        public static const AcousticPiano_D7:Class = Instr_AcousticPiano_D7;
        public static const AltoSax_A3:Class = Instr_AltoSax_A3;
        public static const AltoSax_C6:Class = Instr_AltoSax_C6;
        public static const Bassoon_C3:Class = Instr_Bassoon_C3;
        public static const BassTrombone_A2_2:Class = Instr_BassTrombone_A2_2;
        public static const BassTrombone_A2_3:Class = Instr_BassTrombone_A2_3;
        public static const Cello_C2:Class = Instr_Cello_C2;
        public static const Cello_As2:Class = Instr_Cello_As2;
        public static const Choir_F3:Class = Instr_Choir_F3;
        public static const Choir_F4:Class = Instr_Choir_F4;
        public static const Choir_F5:Class = Instr_Choir_F5;
        public static const Clarinet_C4:Class = Instr_Clarinet_C4;
        public static const ElectricBass_G1:Class = Instr_ElectricBass_G1;
        public static const ElectricGuitar_F3:Class = Instr_ElectricGuitar_F3;
        public static const ElectricPiano_C2:Class = Instr_ElectricPiano_C2;
        public static const ElectricPiano_C4:Class = Instr_ElectricPiano_C4;
        public static const EnglishHorn_D4:Class = Instr_EnglishHorn_D4;
        public static const EnglishHorn_F3:Class = Instr_EnglishHorn_F3;
        public static const Flute_B5_1:Class = Instr_Flute_B5_1;
        public static const Flute_B5_2:Class = Instr_Flute_B5_2;
        public static const Marimba_C4:Class = Instr_Marimba_C4;
        public static const MusicBox_C4:Class = Instr_MusicBox_C4;
        public static const Organ_G2:Class = Instr_Organ_G2;
        public static const Pizz_A3:Class = Instr_Pizz_A3;
        public static const Pizz_E4:Class = Instr_Pizz_E4;
        public static const Pizz_G2:Class = Instr_Pizz_G2;
        public static const SteelDrum_D5:Class = Instr_SteelDrum_D5;
        public static const SynthLead_C4:Class = Instr_SynthLead_C4;
        public static const SynthLead_C6:Class = Instr_SynthLead_C6;
        public static const SynthPad_A3:Class = Instr_SynthPad_A3;
        public static const SynthPad_C6:Class = Instr_SynthPad_C6;
        public static const TenorSax_C3:Class = Instr_TenorSax_C3;
        public static const Trombone_B3:Class = Instr_Trombone_B3;
        public static const Trumpet_E5:Class = Instr_Trumpet_E5;
        public static const Vibraphone_C3:Class = Instr_Vibraphone_C3;
        public static const Violin_D4:Class = Instr_Violin_D4;
        public static const Violin_A4:Class = Instr_Violin_A4;
        public static const Violin_E5:Class = Instr_Violin_E5;
        public static const WoodenFlute_C5:Class = Instr_WoodenFlute_C5;
        public static const BassDrum:Class = Instr_BassDrum;
        public static const Bongo:Class = Instr_Bongo;
        public static const Cabasa:Class = Instr_Cabasa;
        public static const Clap:Class = Instr_Clap;
        public static const Claves:Class = Instr_Claves;
        public static const Conga:Class = Instr_Conga;
        public static const Cowbell:Class = Instr_Cowbell;
        public static const Crash:Class = Instr_Crash;
        public static const Cuica:Class = Instr_Cuica;
        public static const GuiroLong:Class = Instr_GuiroLong;
        public static const GuiroShort:Class = Instr_GuiroShort;
        public static const HiHatClosed:Class = Instr_HiHatClosed;
        public static const HiHatOpen:Class = Instr_HiHatOpen;
        public static const HiHatPedal:Class = Instr_HiHatPedal;
        public static const Maracas:Class = Instr_Maracas;
        public static const SideStick:Class = Instr_SideStick;
        public static const SnareDrum:Class = Instr_SnareDrum;
        public static const Tambourine:Class = Instr_Tambourine;
        public static const Tom:Class = Instr_Tom;
        public static const Triangle:Class = Instr_Triangle;
        public static const Vibraslap:Class = Instr_Vibraslap;
        public static const WoodBlock:Class = Instr_WoodBlock;

        public static var samples:Object;

        public static function initSamples():void{
            var _local2:XML;
            var _local3:String;
            if (samples){
                return;
            };
            samples = {};
            var _local1:XML = describeType(Instr);
            for each (_local2 in _local1.elements("constant")) {
                if (_local2.attribute("type") == "Class"){
                    _local3 = _local2.attribute("name");
                    samples[_local3] = getWAVSamples(new (Instr[_local3])());
                };
            };
        }
        private static function getWAVSamples(_arg1:ByteArray):ByteArray{
            var _local2:Object = WAVFile.decode(_arg1);
            var _local3:ByteArray = new ByteArray();
            _local3.endian = Endian.LITTLE_ENDIAN;
            _arg1.position = _local2.sampleDataStart;
            _arg1.readBytes(_local3, 0, (2 * _local2.sampleCount));
            return (_local3);
        }

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_ElectricPiano_C4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_C4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Trumpet_E5 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SideStick extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_GuiroShort extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_EnglishHorn_F3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Pizz_G2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Vibraphone_C3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Clarinet_C4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Cowbell extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Clap extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_HiHatPedal extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Conga extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SnareDrum extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticGuitar_F3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Vibraslap extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_EnglishHorn_D4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Crash extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Bongo extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Organ_G2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Violin_E5 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_BassTrombone_A2_3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_HiHatClosed extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Choir_F4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_ElectricBass_G1 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Maracas extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Violin_A4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_SteelDrum_D5 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Cuica extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_F5 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_ElectricGuitar_F3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Tambourine extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_MusicBox_C4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_BassDrum extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_G4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Choir_F5 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Claves extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Cello_As2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Tom extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AltoSax_A3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_GuiroLong extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_WoodenFlute_C5 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_HiHatOpen extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Violin_D4 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Pizz_A3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Choir_F3 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_Cello_C2 extends ByteArrayAsset {

    }
}//package soundbank 
package soundbank {
    import mx.core.*;

    public class Instr_AcousticPiano_Ds6 extends ByteArrayAsset {

    }
}//package soundbank 
package {
    import flash.geom.*;
    import scratch.*;
    import flash.events.*;
    import flash.display.*;
    import uiwidgets.*;
    import flash.utils.*;
    import ui.media.*;
    import flash.text.*;
    import blocks.*;
    import interpreter.*;
    import watchers.*;
    import util.*;
    import extensions.*;
    import flash.net.*;
    import ui.parts.*;
    import webcamui.*;
    import ui.*;
    import translation.*;
    import flash.system.*;
    import flash.external.*;

    public class Scratch extends Sprite {

        public static var app:Scratch;

        private const AUTO_SAVE_INTERVAL:int = 60000;
        private const frameRateGraphH:int = 150;

        public var versionString:String = "v301";
        public var runtime:ScratchRuntime;
        public var interp:Interpreter;
        public var extensionManager:ExtensionManager;
        public var persistenceManager:PersistenceManager;
        public var gh:GestureHandler;
        public var editMode:Boolean;
        public var embedMode:Boolean;
        public var stageIsContracted:Boolean;
        public var usesPersistentData:Boolean;
        public var userName:String = "";
        public var projectID:String = "";
        public var projectOwner:String = "";
        public var projectIsPrivate:Boolean;
        public var persistentDataCount:int = 0;
        public var serverSettingsReady:Boolean = true;
        public var oldWebsiteURL:String = "";
        private var serverSettings:Object = null;
        private var autostart:Boolean;
        private var viewedObject:ScratchObj;
        private var lastTab:String = "scripts";
        private var wasEdited:Boolean;
        private var saveInProgress:Boolean;
        private var lastSaveFailed:Boolean;
        private var _usesUserNameBlock:Boolean = false;
        private var languageChanged:Boolean;
        public var playerBG:Shape;
        public var palette:BlockPalette;
        public var scriptsPane:ScriptsPane;
        public var stagePane:ScratchStage;
        public var openBackpack:BackpackPart;
        public var mediaLibrary:MediaLibrary;
        public var lp:LoadProgress;
        public var cameraDialog:WebCamPane;
        public var libraryPart:LibraryPart;
        private var topBarPart:TopBarPart;
        private var stagePart:StagePart;
        private var tabsPart:TabsPart;
        private var scriptsPart:ScriptsPart;
        public var imagesPart:ImagesPart;
        private var soundsPart:SoundsPart;
        public var backpackPart:BackpackPart;
        private var debugRect:Shape;
        private var wasEditing:Boolean;
        private var lastZoom:Number = NaN;
        private var remixRequested:Boolean = false;
        public var saveNeeded:Boolean;
        private var lastCheckTime:int;
        private var lastSaveTime:int;
        private var originalProj:ByteArray;
        private var originalProjOnServer:Boolean;
        private var revertUndo:ByteArray;
        private var frameRateReadout:TextField;
        private var firstFrameTime:int;
        private var frameCount:int;
        private var frameRateGraph:Shape;
        private var nextFrameRateX:int;
        private var lastFrameTime:int;
        private var thumbnailForFlag:String = "";

        public function Scratch(){
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.frameRate = 30;
            Block.setFonts(10, 9, true, 0);
            Block.MenuHandlerFunction = BlockMenus.BlockMenuHandler;
            CursorTool.init(this);
            app = this;
            this.stagePane = new ScratchStage();
            this.gh = new GestureHandler(this);
            this.runtime = new ScratchRuntime(this);
            this.interp = this.runtime.interp;
            this.persistenceManager = new PersistenceManager(this);
            this.extensionManager = new ExtensionManager(this);
            Server.acquirePageURL();
            Translator.initializeLanguageList();
            this.playerBG = new Shape();
            this.addParts();
            stage.addEventListener(MouseEvent.MOUSE_DOWN, this.gh.mouseDown);
            stage.addEventListener(MouseEvent.MOUSE_MOVE, this.gh.mouseMove);
            stage.addEventListener(MouseEvent.MOUSE_UP, this.gh.mouseUp);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, this.runtime.keyDown);
            stage.addEventListener(KeyboardEvent.KEY_UP, this.runtime.keyUp);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, this.keyDown);
            stage.addEventListener(Event.ENTER_FRAME, this.step);
            stage.addEventListener(Event.RESIZE, this.fixLayout);
            this.setEditMode(this.isStandAlone());
            if (this.isStandAlone()){
                this.runtime.installNewProject();
            } else {
                this.runtime.installEmptyProject();
            };
            this.browserTrace(this.versionString);
            this.handleStartupParameters();
            this.fixLayout(null);
            Server.getWebsiteLang(Translator.setLanguage);
        }
        public static function strings():Array{
            return (["This project uses Cloud data ‒ a feature that is available only to signed in users.", "Can’t find network connection or reach server.", "Click \"Save now\" to try again or \"Download\" to save", "a copy of the project file on