API tools faq
paste
stuppid_bot

Untitled

stuppid_bot
Nov 26th, 2013
250
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ActionScript 3 184.98 KB | None | 0 0
raw download clone embed print report
  1. package zopim {
  2.     import flash.events.*;
  3.     import zopim.events.*;
  4.     import flash.net.*;
  5.     import com.adobe.serialization.json.*;
  6.  
  7.     public class ZURLLoader extends URLLoader {
  8.  
  9.         private var callback:Function;
  10.         private var reuse:Boolean;
  11.         private var _eventToListenerMap:Object;
  12.  
  13.         public function ZURLLoader(_arg1:URLRequest=null, _arg2:Boolean=false, _arg3:Function=null){
  14.             _eventToListenerMap = {};
  15.             this.reuse = _arg2;
  16.             if ((_arg3 is Function)){
  17.                 this.callback = _arg3;
  18.             };
  19.             addEventListener(Event.COMPLETE, onComplete, false, 0, true);
  20.             addEventListener(IOErrorEvent.IO_ERROR, onErrorEvent, false, 0, true);
  21.             addEventListener(SecurityErrorEvent.SECURITY_ERROR, onErrorEvent, false, 0, true);
  22.             super(_arg1);
  23.         }
  24.         public static function getURLRequest(_arg1:String, _arg2:String, _arg3:Object):URLRequest{
  25.             var _local6:String;
  26.             ZConfig.traceTime(("httpSocket sending >> " + JSON.encode(_arg3)));
  27.             var _local4:URLRequest = new URLRequest(_arg1);
  28.             _local4.method = _arg2;
  29.             var _local5:URLVariables = new URLVariables();
  30.             for (_local6 in _arg3) {
  31.                 _local5[_local6] = _arg3[_local6];
  32.             };
  33.             if (_local4.method == URLRequestMethod.GET){
  34.                 _local5["random"] = Math.random();
  35.             };
  36.             _local4.data = _local5;
  37.             return (_local4);
  38.         }
  39.  
  40.         private function onErrorEvent(_arg1:ErrorEvent):void{
  41.             ZConfig.traceTime(("ZURLLoader: " + _arg1));
  42.             dispatchEvent(new HTTPSocketEvent(HTTPSocketEvent.HTTPSOCKET_ERROR, _arg1));
  43.         }
  44.         private function cleanUp():void{
  45.             if (!reuse){
  46.                 removeAllListeners();
  47.                 callback = null;
  48.             };
  49.         }
  50.         private function onComplete(_arg1:Event):void{
  51.             var loader:* = null;
  52.             var str:* = null;
  53.             var json:* = null;
  54.             var e:* = _arg1;
  55.             if ((callback is Function)){
  56.                 loader = (e.target as ZURLLoader);
  57.                 str = loader.data;
  58.                 if (((!(str)) || (!(str.length)))){
  59.                     cleanUp();
  60.                     return;
  61.                 };
  62.                 try {
  63.                     json = JSON.decode(str);
  64.                 } catch(error:Error) {
  65.                     ZConfig.traceTime(("Error >> " + error.toString()));
  66.                     dispatchEvent(new HTTPSocketEvent(HTTPSocketEvent.JSON_PARSE_ERROR, error));
  67.                     cleanUp();
  68.                     return;
  69.                 };
  70.                 ZConfig.traceTime(("ZURLLoader received: " + str));
  71.                 callback(json);
  72.             };
  73.             cleanUp();
  74.         }
  75.         override public function addEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false, _arg4:int=0, _arg5:Boolean=false):void{
  76.             super.addEventListener(_arg1, _arg2, _arg3, _arg4, _arg5);
  77.             if (_arg5){
  78.                 return;
  79.             };
  80.             if (_eventToListenerMap[_arg1]){
  81.                 (_eventToListenerMap[_arg1] as Array).push(_arg2);
  82.             } else {
  83.                 _eventToListenerMap[_arg1] = [_arg2];
  84.             };
  85.         }
  86.         public function removeAllListeners():void{
  87.             var _local1:String;
  88.             var _local2:Array;
  89.             var _local3:Function;
  90.             for (_local1 in _eventToListenerMap) {
  91.                 _local2 = _eventToListenerMap[_local1];
  92.                 for each (_local3 in _local2) {
  93.                     super.removeEventListener(_local1, _local3);
  94.                 };
  95.             };
  96.         }
  97.         override public function load(_arg1:URLRequest):void{
  98.             var request:* = _arg1;
  99.             try {
  100.                 super.load(request);
  101.             } catch(error:Error) {
  102.                 ZConfig.traceTime("Unable to load requested document.");
  103.             };
  104.         }
  105.  
  106.     }
  107. }//package zopim
  108. package zopim {
  109.     import zopim.net.*;
  110.     import com.adobe.crypto.*;
  111.     import flash.external.*;
  112.  
  113.     public class ZConfig {
  114.  
  115.         private static const DEFAULT_ACCOUNT_KEY:String = ((DEBUG) ? "demo" : null);
  116. ;
  117.         public static const DEFAULT_HOST:String = "zopim.com";
  118.         private static const _MAP = {
  119.             machineID:String,
  120.             displayName:String,
  121.             sessionID:String,
  122.             name:String,
  123.             meta:String
  124.         };
  125.  
  126.         public static var DEBUG:Boolean = false;
  127.         public static var ZDASHBOARD_CONFIG:String = "zdashboard_config";
  128.         public static var ZCLIENT_CONFIG:String = "zclient_config";
  129.         private static var zopSO:ZSharedObject = new ZSharedObject("ZopConfig");
  130.         public static var type:String = ZCLIENT_CONFIG;
  131.         protected static var _baseDomain:String;
  132.         protected static var _isSecure:Boolean;
  133.         protected static var _uriScheme:String;
  134.         private static var _accountKey:String;
  135.         private static var _secretKey:String;
  136.         private static var _locationHost:String;
  137.         private static var _tabIdentifier:String;
  138.         private static var _ua:String;
  139.         private static var _pageTitle:String;
  140.         public static var logs:Array = [];
  141.         private static var MAX_LINES:uint = 500;
  142.         private static var _start:String = "";
  143.         private static var _end:String = "*********************************************";
  144.  
  145.         public static function init(_arg1:String):void{
  146.             type = _arg1;
  147.             if (DEBUG){
  148.             };
  149.         }
  150.         public static function get baseDomain():String{
  151.             if (!_baseDomain){
  152.                 _baseDomain = ((type)==ZCLIENT_CONFIG) ? getScriptDomain() : getURLDomain();
  153.             };
  154.             return (_baseDomain);
  155.         }
  156.         private static function getScriptDomain():String{
  157.             try {
  158.                 _baseDomain = ExternalInterface.call("eval", "__$$__meshim__Config.baseDomain");
  159.                 _baseDomain = _baseDomain.replace(/https?:\/\//i, "");
  160.                 if (((!(_baseDomain)) || (!(_baseDomain.length)))){
  161.                     return ((_baseDomain = DEFAULT_HOST));
  162.                 };
  163.                 _baseDomain = ((_baseDomain.search("livechat."))==0) ? _baseDomain : "zopim.com";
  164.                 return (_baseDomain);
  165.             } catch(e:Error) {
  166.             };
  167.             return ((_baseDomain = DEFAULT_HOST));
  168.         }
  169.         private static function getURLDomain():String{
  170.             try {
  171.                 _baseDomain = ExternalInterface.call("eval", "document.location.host");
  172.                 if (((!(_baseDomain)) || (!(_baseDomain.length)))){
  173.                     return ((_baseDomain = DEFAULT_HOST));
  174.                 };
  175.                 _baseDomain = _baseDomain.replace(/^(dashboard|desktop|labs)./i, "");
  176.                 _baseDomain = ((_baseDomain.search("livechat."))==0) ? _baseDomain : "zopim.com";
  177.                 return (_baseDomain);
  178.             } catch(e:Error) {
  179.             };
  180.             return ((_baseDomain = DEFAULT_HOST));
  181.         }
  182.         public static function get zSocketHost():String{
  183.             return (("g88.talk." + baseDomain));
  184.         }
  185.         protected static function checkUriScheme():void{
  186.             var _local1:String;
  187.             var _local2:String;
  188.             try {
  189.                 _local1 = ExternalInterface.call("eval", "__$$__meshim__Config.baseURL");
  190.                 if (_local1){
  191.                     _local2 = _local1.split(":")[0];
  192.                     if (_local2.toLowerCase() == "https"){
  193.                         _isSecure = true;
  194.                         _uriScheme = "https://";
  195.                         return;
  196.                     };
  197.                 } else {
  198.                     if (ExternalInterface.call("eval", "document.location.protocol == 'https:'")){
  199.                         _isSecure = true;
  200.                         _uriScheme = "https://";
  201.                         return;
  202.                     };
  203.                 };
  204.             } catch(e:Error) {
  205.             };
  206.             _uriScheme = "http://";
  207.             _isSecure = false;
  208.         }
  209.         public static function get isSecure():Boolean{
  210.             if (_uriScheme){
  211.                 return (_isSecure);
  212.             };
  213.             checkUriScheme();
  214.             return (_isSecure);
  215.         }
  216.         public static function get uriScheme():String{
  217.             if (_uriScheme){
  218.                 return (_uriScheme);
  219.             };
  220.             checkUriScheme();
  221.             return (_uriScheme);
  222.         }
  223.         public static function loadValue(_arg1:String):String{
  224.             return (zopSO.data[_arg1]);
  225.         }
  226.         public static function saveValue(_arg1:String, _arg2):void{
  227.             zopSO.data[_arg1] = _arg2;
  228.             zopSO.flush();
  229.         }
  230.         public static function clear():void{
  231.             zopSO.clear();
  232.         }
  233.         public static function get accountKey():String{
  234.             if (!_accountKey){
  235.                 try {
  236.                     _accountKey = ((ExternalInterface.call("eval", "__$$__meshim__Config.accountKey")) || (DEFAULT_ACCOUNT_KEY));
  237.                 } catch(e:Error) {
  238.                     _accountKey = "";
  239.                 };
  240.             };
  241.             return (_accountKey);
  242.         }
  243.         public static function get secretKey():String{
  244.             if (_secretKey){
  245.                 return (_secretKey);
  246.             };
  247.             _secretKey = loadValue("secretKey");
  248.             if (((!(_secretKey)) || (!(_secretKey.match(/[a-zA-Z0-9]{40}/))))){
  249.                 _secretKey = SHA1.hash((("fuck adobe" + Math.random()) + new Date().getTime()));
  250.                 traceTime(("Creating secret >> " + _secretKey));
  251.                 saveValue("secretKey", _secretKey);
  252.             };
  253.             return (_secretKey);
  254.         }
  255.         public static function get machineID():String{
  256.             return (loadValue("machineID"));
  257.         }
  258.         public static function get sessionID():String{
  259.             return (loadValue(("sessionID_" + accountKey)));
  260.         }
  261.         public static function get locationHost():String{
  262.             var _local1:String;
  263.             var _local2:String;
  264.             var _local3:String;
  265.             var _local4:Array;
  266.             try {
  267.                 if (_locationHost){
  268.                     return (_locationHost);
  269.                 };
  270.                 _local1 = ExternalInterface.call("eval", "location.host");
  271.                 _local2 = ExternalInterface.call("eval", "location.protocol");
  272.                 _local3 = ExternalInterface.call("eval", "location.pathname");
  273.                 _local4 = _local3.match(new RegExp("/.+/"));
  274.                 _local3 = ((((_local4) && (_local4.length))) ? _local4[0].substr(0, (_local4[0].length - 1)) : "");
  275.                 if (((((_local1) && (_local1.length))) && (!((_local2.toLowerCase() == "file:"))))){
  276.                     return ((_locationHost = (((_local2 + "//") + _local1) + _local3)));
  277.                 };
  278.             } catch(e:Error) {
  279.             };
  280.             return ((_locationHost = "http://dashboard.zopim.com"));
  281.         }
  282.         public static function get pageUrl():String{
  283.             try {
  284.                 return (ExternalInterface.call("eval", "location.href"));
  285.             } catch(e:Error) {
  286.             };
  287.             return ("");
  288.         }
  289.         public static function get referrer():String{
  290.             try {
  291.                 return (ExternalInterface.call("eval", "document.referrer"));
  292.             } catch(e:Error) {
  293.             };
  294.             return ("");
  295.         }
  296.         public static function get tabIdentifier():String{
  297.             if (!_tabIdentifier){
  298.                 try {
  299.                     _tabIdentifier = ExternalInterface.call("eval", "window.name");
  300.                     if (!_tabIdentifier){
  301.                         _tabIdentifier = ("_flash_" + SHA1.hash((("fuck adobe" + Math.random()) + new Date().getTime())));
  302.                         ExternalInterface.call("eval", (("window.name = \"" + _tabIdentifier) + "\""));
  303.                     };
  304.                 } catch(e:Error) {
  305.                     _tabIdentifier = ("_flash_" + SHA1.hash((("fuck adobe" + Math.random()) + new Date().getTime())));
  306.                 };
  307.             };
  308.             return (_tabIdentifier);
  309.         }
  310.         public static function get ua():String{
  311.             if (_ua){
  312.                 return (_ua);
  313.             };
  314.             try {
  315.                 _ua = ((ExternalInterface.call("eval", "navigator.userAgent")) || (""));
  316.             } catch(e:Error) {
  317.                 _ua = "";
  318.             };
  319.             return (_ua);
  320.         }
  321.         public static function get pageTitle():String{
  322.             if (_pageTitle){
  323.                 return (_pageTitle);
  324.             };
  325.             try {
  326.                 _pageTitle = ((ExternalInterface.call("eval", "document.title")) || (""));
  327.             } catch(e:Error) {
  328.                 _pageTitle = "";
  329.             };
  330.             return (_pageTitle);
  331.         }
  332.         public static function update(_arg1:Object):void{
  333.             var _local2:String;
  334.             for (_local2 in _arg1) {
  335.                 if ((((_local2 in _MAP)) && ((_arg1[_local2] is _MAP[_local2])))){
  336.                     saveValue(_local2, _arg1[_local2]);
  337.                     traceTime(((("Saved " + _local2) + "-> ") + _arg1[_local2]));
  338.                 };
  339.             };
  340.         }
  341.         public static function traceTime(_arg1):void{
  342.             var _local2:String;
  343.             if (DEBUG){
  344.                 _start = (("\n******** " + new Date().toUTCString()) + " ********");
  345.                 _local2 = new String(_arg1);
  346.                 logs = logs.concat(_start, _local2.split(/[\r\n]/g), _end);
  347.                 if (logs.length > MAX_LINES){
  348.                     logs.splice(MAX_LINES, (logs.length - MAX_LINES));
  349.                 };
  350.             };
  351.         }
  352.  
  353.     }
  354. }//package zopim
  355. package zopim {
  356.     import flash.events.*;
  357.     import zopim.events.*;
  358.     import flash.utils.*;
  359.     import flash.net.*;
  360.     import com.adobe.serialization.json.*;
  361.     import flash.external.*;
  362.  
  363.     public class HTTPSocket extends EventDispatcher {
  364.  
  365.         private static const CROSSDOMAIN_FILE:String = "crossdomain.xml";
  366.         private static const TYPES_WHICH_REQUIRES_ERROR_EVENTS_TO_BE_FIRED:Object = {
  367.             reattach:true,
  368.             login:true,
  369.             register:true,
  370.             poll:true,
  371.             ping:true
  372.         };
  373.  
  374.         private static var _httpGenericUrl:String;
  375.         private static var _httpServicesUrl:String;
  376.         private static var _pollingUrl:String;
  377.         private static var _sendURL:String;
  378.         private static var _registerUrl:String;
  379.         public static var shortPollingDelay:uint = 3000;
  380.         public static var longPollingDelay:uint = 500;
  381.         public static var longPollingDuration:uint = 0;
  382.         private static var POLL_TIMEOUT:uint = 55000;
  383.         public static var pollingUrl:String;
  384.         public static var sendURL:String;
  385.  
  386.         private var _host:String;
  387.         private var ak:String;
  388.         private var shortPoll:Boolean;
  389.         public var evt:uint = 0;
  390.         private var pollingConnection:ZURLLoader;
  391.         private var zSocket:ZSocket;
  392.         public var sid:String;
  393.         private var pollTimeoutId:uint = 0;
  394.         private var requestsBuffer:Array;
  395.  
  396.         public function HTTPSocket(_arg1:String=""){
  397.             var host:String = _arg1;
  398.             requestsBuffer = [];
  399.             super();
  400.             this.host = ((host) || (ZConfig.zSocketHost));
  401.             ak = ZConfig.accountKey;
  402.             try {
  403.                 shortPoll = ExternalInterface.call(((((((("function(){" + "var ua = navigator.userAgent.toLowerCase(), ") + "isIE        = ua.indexOf('msie') > -1, ") + "isIE8       = ua.indexOf('msie 8') > -1,") + "isIE7       = ua.indexOf('msie 7') > -1 && !isIE8,") + "isIE6       = ua.indexOf('msie 6') > -1 && !isIE8 && !isIE7;") + "return isIE6 || isIE7;") + "}"));
  404.             } catch(e:Error) {
  405.                 shortPoll = false;
  406.             };
  407.         }
  408.         public static function get httpGenericUrl():String{
  409.             if (!_httpGenericUrl){
  410.                 _httpGenericUrl = (((ZConfig.uriScheme + "www.") + ZConfig.baseDomain) + "/");
  411.             };
  412.             return (_httpGenericUrl);
  413.         }
  414.         public static function get httpServicesUrl():String{
  415.             if (!_httpServicesUrl){
  416.                 _httpServicesUrl = (((ZConfig.uriScheme + "init.") + ZConfig.baseDomain) + "/");
  417.             };
  418.             return (_httpServicesUrl);
  419.         }
  420.         public static function get registerUrl():String{
  421.             if (!_registerUrl){
  422.                 _registerUrl = (((ZConfig.uriScheme + "init.") + ZConfig.baseDomain) + "/register");
  423.             };
  424.             return (_registerUrl);
  425.         }
  426.         public static function sendJson(_arg1:String, _arg2:Object, _arg3:String="POST", _arg4:Function=null):ZURLLoader{
  427.             var _local5:URLRequest = ZURLLoader.getURLRequest(_arg1, _arg3, _arg2);
  428.             return (new ZURLLoader(_local5, false, _arg4));
  429.         }
  430.  
  431.         public function set host(_arg1:String):void{
  432.             _host = _arg1;
  433.             pollingUrl = ((ZConfig.uriScheme + _host) + "/poll");
  434.             sendURL = ((ZConfig.uriScheme + _host) + "/send");
  435.         }
  436.         public function get host():String{
  437.             return (_host);
  438.         }
  439.         private function onURLLoaderErrorEvent(_arg1:Event):void{
  440.             var _local2:ZURLLoader = ZURLLoader(_arg1.target);
  441.             if (_local2 == pollingConnection){
  442.                 pollingConnection = null;
  443.             };
  444.             ZConfig.traceTime(("onURLLoaderErrorEvent: " + _arg1));
  445.             dispatchConnectionError({
  446.                 __status:"failed",
  447.                 type:_arg1.type
  448.             });
  449.             _local2.removeAllListeners();
  450.         }
  451.         private function configureListeners(_arg1:ZURLLoader):void{
  452.             _arg1.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onURLLoaderErrorEvent, false, 0, true);
  453.             _arg1.addEventListener(IOErrorEvent.IO_ERROR, onURLLoaderErrorEvent, false, 0, true);
  454.             _arg1.addEventListener(HTTPSocketEvent.JSON_PARSE_ERROR, onURLLoaderErrorEvent, false, 0, true);
  455.         }
  456.         public function send(_arg1:String, _arg2:Object, _arg3:String="POST"):void{
  457.             if (requestsBuffer.length){
  458.                 requestsBuffer.push(_arg2);
  459.             } else {
  460.                 requestsBuffer.push(_arg2);
  461.                 setTimeout(_send, 50, _arg1, requestsBuffer, _arg3);
  462.             };
  463.         }
  464.         private function _send(_arg1:String, _arg2:Object, _arg3:String="POST"){
  465.             var callback:* = null;
  466.             var type:* = _arg1;
  467.             var obj:* = _arg2;
  468.             var method:String = _arg3;
  469.             callback = function (_arg1:Object):void{
  470.                 var _local2:Object;
  471.                 if ((_arg1 is Array)){
  472.                     for each (_local2 in _arg1) {
  473.                         dispatchEvent(new HTTPSocketEvent(HTTPSocketEvent.HTTPSOCKET_DATA_READY, _local2));
  474.                     };
  475.                 } else {
  476.                     dispatchEvent(new HTTPSocketEvent(HTTPSocketEvent.HTTPSOCKET_DATA_READY, _arg1));
  477.                 };
  478.             };
  479.             var urlLoader:* = sendJson(sendURL, ((sid) ? {
  480.     sid:sid,
  481.     msg:JSON.encode(obj)
  482. } : {msg:JSON.encode(obj)}), method, callback);
  483.             configureListeners(urlLoader);
  484.             requestsBuffer.splice(0, requestsBuffer.length);
  485.         }
  486.         public function sendRegister(_arg1:Object, _arg2:Function=null, _arg3:Function=null):void{
  487.             var _local4:ZURLLoader = sendJson(registerUrl, _arg1, URLRequestMethod.POST, _arg2);
  488.             _local4.addEventListener(SecurityErrorEvent.SECURITY_ERROR, _arg3, false, 0, true);
  489.             _local4.addEventListener(IOErrorEvent.IO_ERROR, _arg3, false, 0, true);
  490.             _local4.addEventListener(HTTPSocketEvent.JSON_PARSE_ERROR, _arg3, false, 0, true);
  491.         }
  492.         private function dispatchConnectionError(_arg1:Object=null):void{
  493.             stopPoll();
  494.             dispatchEvent(new HTTPSocketEvent(HTTPSocketEvent.HTTPSOCKET_ERROR, _arg1));
  495.         }
  496.         public function startPoll(_arg1:Object=null):void{
  497.             _arg1 = ((_arg1) || ({}));
  498.             ZConfig.traceTime(("start polling @ " + host));
  499.             if (isPolling){
  500.                 return;
  501.             };
  502.             pollingConnection = new ZURLLoader(null, true, polled);
  503.             configureListeners(pollingConnection);
  504.             evt = ((evt) || (_arg1.evt));
  505.             sid = ((_arg1.sid) || (sid));
  506.             poll();
  507.         }
  508.         public function stopPoll():void{
  509.             if (!isPolling){
  510.                 return;
  511.             };
  512.             ZConfig.traceTime("stop polling");
  513.             clearTimeout(pollTimeoutId);
  514.             pollingConnection.close();
  515.             pollingConnection.removeAllListeners();
  516.             pollingConnection = null;
  517.             sid = null;
  518.             evt = 0;
  519.         }
  520.         private function onPollTimeout():void{
  521.             dispatchConnectionError({
  522.                 __status:"failed",
  523.                 type:"poll_timeout"
  524.             });
  525.         }
  526.         public function get isPolling():Boolean{
  527.             return ((pollingConnection is ZURLLoader));
  528.         }
  529.         private function poll():void{
  530.             if (!isPolling){
  531.                 return;
  532.             };
  533.             ZConfig.traceTime("poll!");
  534.             var _local1:URLRequest = ZURLLoader.getURLRequest(pollingUrl, URLRequestMethod.POST, ((shortPoll) ? {
  535.     evt:evt,
  536.     ak:ak,
  537.     sid:sid,
  538.     short:1
  539. } : ((longPollingDuration) ? {
  540.     evt:evt,
  541.     ak:ak,
  542.     sid:sid,
  543.     long:longPollingDuration
  544. } : {
  545.     evt:evt,
  546.     ak:ak,
  547.     sid:sid
  548. })));
  549.             pollingConnection.load(_local1);
  550.             clearTimeout(pollTimeoutId);
  551.             pollTimeoutId = setTimeout(onPollTimeout, POLL_TIMEOUT);
  552.         }
  553.         private function polled(_arg1:Object):void{
  554.             var i:* = 0;
  555.             var events:* = _arg1;
  556.             clearTimeout(pollTimeoutId);
  557.             ZConfig.traceTime("polled");
  558.             try {
  559.                 if (events.__status != "ok"){
  560.                     dispatchConnectionError(events);
  561.                     return;
  562.                 };
  563.                 if (events.evt){
  564.                     evt = events.evt;
  565.                 };
  566.                 if (((events.events) && (events.events.length))){
  567.                     i = 0;
  568.                     while (i < events.events.length) {
  569.                         ZConfig.traceTime(("dispatching :" + JSON.encode(events.events[i])));
  570.                         dispatchEvent(new HTTPSocketEvent(HTTPSocketEvent.HTTPSOCKET_DATA_READY, events.events[i]));
  571.                         i = (i + 1);
  572.                     };
  573.                 };
  574.             } catch(error:Error) {
  575.                 ZConfig.traceTime("bad json");
  576.             };
  577.             setTimeout(poll, ((shortPoll) ? shortPollingDelay : longPollingDelay));
  578.         }
  579.  
  580.     }
  581. }//package zopim
  582. package zopim {
  583.     import flash.events.*;
  584.     import zopim.net.*;
  585.     import zopim.events.*;
  586.     import flash.utils.*;
  587.     import flash.net.*;
  588.     import flash.system.*;
  589.     import flash.errors.*;
  590.  
  591.     public class ZSocket extends EventDispatcher {
  592.  
  593.         protected static const KEEP_ALIVE_PERIOD:int = 240000;
  594.         protected static const SECURITY_POLICY_PORT:int = 843;
  595.         public static const NO_CONNECTION:uint = 0;
  596.         public static const SOCKET_CONNECTION:uint = 1;
  597.         public static const POLLING_CONNECTION:uint = 2;
  598.         public static const ZSOCKET_PORT:uint = 20913;
  599.  
  600.         public const DEFAULT_RECONNECT_DELAY:uint = 1000;
  601.         protected const MAX_RECONNECT_DELAY:uint = 60000;
  602.  
  603.         public var sid:String;
  604.         protected var socket:_ZSocket;
  605.         protected var httpSocket:HTTPSocket;
  606.         protected var _nick:String;
  607.         protected var callbacks:Array;
  608.         protected var messageID:uint;
  609.         protected var keepAliveIntervalId:uint = 0;
  610.         protected var reconnectDelay:uint = 1000;
  611.         private var _host:String;
  612.         public var port:uint = 20913;
  613.         protected var _connectionMode:uint = 0;
  614.         protected var connectTimeoutId:uint = 0;
  615.  
  616.         public function ZSocket(){
  617.             _host = ZConfig.zSocketHost;
  618.             super();
  619.             callbacks = [];
  620.             messageID = (Math.random() * 10000);
  621.             ZConfig.traceTime(("Sandbox: " + Security.sandboxType));
  622.             httpSocket = new HTTPSocket();
  623.             socket = new _ZSocket();
  624.         }
  625.         public function get connected():Boolean{
  626.             if (connectionMode == POLLING_CONNECTION){
  627.                 return (httpSocket.isPolling);
  628.             };
  629.             if (connectionMode == SOCKET_CONNECTION){
  630.                 return (socket.connected);
  631.             };
  632.             return (false);
  633.         }
  634.         public function set host(_arg1:String):void{
  635.             _host = (httpSocket.host = _arg1);
  636.         }
  637.         public function get host():String{
  638.             return (_host);
  639.         }
  640.         public function set longPollingDuration(_arg1:uint):void{
  641.             HTTPSocket.longPollingDuration = _arg1;
  642.         }
  643.         public function set shortPollingDelay(_arg1:uint):void{
  644.             HTTPSocket.shortPollingDelay = _arg1;
  645.         }
  646.         public function connect(_arg1:String="", _arg2:uint=0):void{
  647.             if (this.connected){
  648.                 return;
  649.             };
  650.             if (_arg1){
  651.                 this.host = _arg1;
  652.             };
  653.             if (_arg2){
  654.                 this.port = _arg2;
  655.             };
  656.             if (ZConfig.isSecure){
  657.                 httpFallback();
  658.             } else {
  659.                 configureListeners();
  660.                 socket.connect(this.host, this.port);
  661.                 setTimeout(httpFallback, 5000);
  662.             };
  663.         }
  664.         public function send(_arg1:String, _arg2:Object=null, _arg3:Function=null):void{
  665.             if (((((((!((_arg1 == "login"))) && (!((_arg1 == "register"))))) && (!((_arg1 == "reattach"))))) && (!(connected)))){
  666.                 ZConfig.traceTime("Send failed > ZSocket not connected");
  667.                 return;
  668.             };
  669.             if ((_arg3 is Function)){
  670.                 callbacks[messageID] = _arg3;
  671.                 _arg2["__messageID"] = messageID++;
  672.             };
  673.             _arg2 = ((_arg2) || (new Object()));
  674.             _arg2["__type"] = _arg1;
  675.             if (_connectionMode == SOCKET_CONNECTION){
  676.                 socket.send(_arg2);
  677.             } else {
  678.                 if (_connectionMode == POLLING_CONNECTION){
  679.                     httpSocket.send(_arg1, _arg2, URLRequestMethod.POST);
  680.                 };
  681.             };
  682.         }
  683.         public function disconnect():void{
  684.             if (((socket) && (socket.connected))){
  685.                 ZConfig.traceTime("Closing socket connection");
  686.                 socket.close();
  687.             };
  688.             if (httpSocket.isPolling){
  689.                 ZConfig.traceTime("Closing polling connection");
  690.                 httpSocket.stopPoll();
  691.             };
  692.             connectionMode = NO_CONNECTION;
  693.             sid = null;
  694.             httpSocket.evt = 0;
  695.             removeHttpSocketEventListeners();
  696.             removeSocketEventListeners();
  697.             clearTimeout(connectTimeoutId);
  698.         }
  699.         protected function keepAlive():void{
  700.             send("ping");
  701.         }
  702.         public function dispatchConnectionError(_arg1:Object=null):void{
  703.             socket.stopReconnecting();
  704.             connectionMode = NO_CONNECTION;
  705.             if (!_arg1){
  706.                 _arg1 = {};
  707.             };
  708.             _arg1["__type"] = "connection.error";
  709.             ZConfig.traceTime(_arg1["__type"]);
  710.             dispatchObject(_arg1);
  711.         }
  712.         public function dispatchObject(_arg1:Object):void{
  713.             var _local3:Function;
  714.             var _local4:ZEvent;
  715.             if (!_arg1){
  716.                 return;
  717.             };
  718.             var _local2:String = _arg1["__type"];
  719.             if (_local2 == "response"){
  720.                 _local3 = callbacks[_arg1["__messageID"]];
  721.                 if ((_local3 is Function)){
  722.                     _local3(_arg1);
  723.                     callbacks[_arg1["__messageID"]] = null;
  724.                 };
  725.             } else {
  726.                 _local4 = jsonMap.jsonToEvent(_arg1);
  727.                 dispatchEvent(_local4);
  728.             };
  729.         }
  730.         public function get nick():String{
  731.             return (_nick);
  732.         }
  733.         protected function set connectionMode(_arg1:uint):void{
  734.             ZConfig.traceTime(("_connectionMode set >> " + (((_arg1 == 0)) ? "NO_CONNECTION" : (((_arg1 == 1)) ? "SOCKET_CONNECTION" : "POLLING_CONNECTION"))));
  735.             _connectionMode = _arg1;
  736.         }
  737.         protected function get connectionMode():uint{
  738.             return (_connectionMode);
  739.         }
  740.         protected function httpFallback():void{
  741.             if (connectionMode != NO_CONNECTION){
  742.                 return;
  743.             };
  744.             ZConfig.traceTime("Falling back to HTTP Polling Connection");
  745.             removeHttpSocketEventListeners();
  746.             addHttpSocketEventListeners();
  747.             connectionMode = POLLING_CONNECTION;
  748.         }
  749.         private function removeHttpSocketEventListeners():void{
  750.             httpSocket.removeEventListener(HTTPSocketEvent.HTTPSOCKET_ERROR, onHTTPSocketEvents);
  751.             httpSocket.removeEventListener(HTTPSocketEvent.HTTPSOCKET_DATA_READY, onHTTPSocketEvents);
  752.         }
  753.         private function addHttpSocketEventListeners():void{
  754.             httpSocket.addEventListener(HTTPSocketEvent.HTTPSOCKET_ERROR, onHTTPSocketEvents, false, 0, true);
  755.             httpSocket.addEventListener(HTTPSocketEvent.HTTPSOCKET_DATA_READY, onHTTPSocketEvents, false, 0, true);
  756.         }
  757.         private function onHTTPSocketEvents(_arg1:HTTPSocketEvent):void{
  758.             if (_arg1.type == HTTPSocketEvent.HTTPSOCKET_DATA_READY){
  759.                 dispatchObject(_arg1.response);
  760.             } else {
  761.                 if (_arg1.type == HTTPSocketEvent.HTTPSOCKET_ERROR){
  762.                     if (connectionMode == POLLING_CONNECTION){
  763.                         dispatchConnectionError(_arg1.response);
  764.                     };
  765.                 };
  766.             };
  767.         }
  768.         protected function configureListeners():void{
  769.             removeSocketEventListeners();
  770.             addSocketEventListeners();
  771.         }
  772.         private function removeSocketEventListeners():void{
  773.             socket.removeEventListener(Event.CONNECT, onConnect);
  774.             socket.removeEventListener(ZSocketEvent.SOCKET_ERROR, onSocketEvents);
  775.             socket.removeEventListener(ZSocketEvent.SOCKET_DATA_READY, onSocketEvents);
  776.             removeEventListener(ZErrorConnection.TYPE, onErrorConnection);
  777.         }
  778.         private function addSocketEventListeners():void{
  779.             socket.addEventListener(Event.CONNECT, onConnect, false, 0, true);
  780.             socket.addEventListener(ZSocketEvent.SOCKET_ERROR, onSocketEvents, false, 0, true);
  781.             socket.addEventListener(ZSocketEvent.SOCKET_DATA_READY, onSocketEvents, false, 0, true);
  782.             addEventListener(ZErrorConnection.TYPE, onErrorConnection, false, 0, true);
  783.         }
  784.         private function onSocketEvents(_arg1:ZSocketEvent):void{
  785.             if (_arg1.type == ZSocketEvent.SOCKET_DATA_READY){
  786.                 dispatchObject(_arg1.response);
  787.             } else {
  788.                 if (_arg1.type == ZSocketEvent.SOCKET_ERROR){
  789.                     if (connectionMode == SOCKET_CONNECTION){
  790.                         dispatchConnectionError(_arg1.response);
  791.                     } else {
  792.                         if (reconnectDelay == DEFAULT_RECONNECT_DELAY){
  793.                             httpFallback();
  794.                         };
  795.                     };
  796.                 };
  797.             };
  798.         }
  799.         protected function onConnect(_arg1:Event):void{
  800.             ZConfig.traceTime(("Event.CONNECT >> " + _arg1.toString()));
  801.             connectionMode = SOCKET_CONNECTION;
  802.             httpSocket.stopPoll();
  803.         }
  804.         protected function onErrorConnection(_arg1:ZErrorConnection=null):void{
  805.             clearTimeout(connectTimeoutId);
  806.             ZConfig.traceTime((("ZSocket reconnecting in " + (reconnectDelay / 1000)) + "secs."));
  807.             connectTimeoutId = setTimeout(connect, reconnectDelay);
  808.             reconnectDelay = (reconnectDelay + (((reconnectDelay < MAX_RECONNECT_DELAY)) ? reconnectDelay : 0));
  809.         }
  810.         public function reattach():void{
  811.             if (sid){
  812.                 send("reattach", {sid:sid}, onReattach);
  813.             };
  814.         }
  815.         protected function startKeepAlive():void{
  816.             clearTimeout(keepAliveIntervalId);
  817.             keepAliveIntervalId = setInterval(keepAlive, KEEP_ALIVE_PERIOD);
  818.         }
  819.         protected function stopKeepAlive():void{
  820.         }
  821.         protected function startPoll(_arg1:Object):void{
  822.             var _local2:Object;
  823.             if (connectionMode == POLLING_CONNECTION){
  824.                 _local2 = {sid:((_arg1["sid"]) || (sid))};
  825.                 if (("evt" in _arg1)){
  826.                     _local2["evt"] = _arg1.evt;
  827.                 };
  828.                 httpSocket.startPoll(_local2);
  829.                 socket.reconnect();
  830.             };
  831.         }
  832.         protected function onReattach(_arg1:Object):void{
  833.             if (_arg1.__status == "ok"){
  834.                 startPoll(_arg1);
  835.                 startKeepAlive();
  836.                 reconnectDelay = DEFAULT_RECONNECT_DELAY;
  837.             } else {
  838.                 sid = null;
  839.                 dispatchConnectionError(_arg1);
  840.             };
  841.         }
  842.  
  843.     }
  844. }//package zopim
  845. package zopim.events {
  846.     import flash.events.*;
  847.  
  848.     public class HTTPSocketEvent extends Event {
  849.  
  850.         public static const HTTPSOCKET_ERROR:String = "httpsocket_error";
  851.         public static const HTTPSOCKET_DATA_READY:String = "httpsocket_data_ready";
  852.         public static const JSON_PARSE_ERROR:String = "json_parse_error";
  853.  
  854.         public var response:Object;
  855.  
  856.         public function HTTPSocketEvent(_arg1:String, _arg2:Object, _arg3:Boolean=false, _arg4:Boolean=false){
  857.             super(_arg1, _arg3, _arg4);
  858.             this.response = _arg2;
  859.         }
  860.     }
  861. }//package zopim.events
  862. package zopim.events {
  863.  
  864.     public class ZErrorConnection extends ZError {
  865.  
  866.         public static const TYPE:String = (ZError.TYPE + ".connection");
  867.  
  868.         public function ZErrorConnection(_arg1:Object, _arg2:String=null){
  869.             super(_arg1, ((_arg2) || (TYPE)));
  870.         }
  871.     }
  872. }//package zopim.events
  873. package zopim.events {
  874.  
  875.     public class ZConfiguration extends ZEvent {
  876.  
  877.         public static const TYPE:String = (ZEvent.TYPE + ".config");
  878.  
  879.         public var meta:String;
  880.         public var machineID:String;
  881.         public var sessionID:String;
  882.         public var displayName:String;
  883.  
  884.         public function ZConfiguration(_arg1:Object, _arg2:String=null){
  885.             super(_arg1, ((_arg2) || (TYPE)));
  886.             meta = _arg1["meta"];
  887.             machineID = _arg1["machineID"];
  888.             sessionID = _arg1["sessionID"];
  889.             displayName = _arg1["displayName"];
  890.         }
  891.     }
  892. }//package zopim.events
  893. package zopim.events {
  894.  
  895.     public class ZReset extends ZEvent {
  896.  
  897.         public static const TYPE:String = (ZEvent.TYPE + ".reset");
  898.  
  899.         public var machineID:String;
  900.         public var nick:String;
  901.         public var name:String;
  902.         public var sid:String;
  903.         public var evt:uint;
  904.  
  905.         public function ZReset(_arg1:Object, _arg2:String=null){
  906.             super(_arg1, ((_arg2) || (TYPE)));
  907.         }
  908.     }
  909. }//package zopim.events
  910. package zopim.events {
  911.     import flash.events.*;
  912.  
  913.     public class ZSocketEvent extends Event {
  914.  
  915.         public static const SOCKET_ERROR:String = "socket_error";
  916.         public static const SOCKET_DATA_READY:String = "socket_data_ready";
  917.  
  918.         public var response:Object;
  919.  
  920.         public function ZSocketEvent(_arg1:String, _arg2:Object, _arg3:Boolean=false, _arg4:Boolean=false){
  921.             super(_arg1, _arg3, _arg4);
  922.             this.response = _arg2;
  923.         }
  924.     }
  925. }//package zopim.events
  926. package zopim.events {
  927.  
  928.     public class ZIdleDisconnect extends ZEvent {
  929.  
  930.         public static const TYPE:String = (ZEvent.TYPE + ".idle.disconnect");
  931.  
  932.         public function ZIdleDisconnect(_arg1:Object, _arg2:String=null){
  933.             super(_arg1, ((_arg2) || (TYPE)));
  934.         }
  935.     }
  936. }//package zopim.events
  937. package zopim.events {
  938.     import flash.events.*;
  939.     import mx.events.*;
  940.  
  941.     public class ZChat extends ZEvent implements IEventDispatcher {
  942.  
  943.         public static const TYPE:String = (ZEvent.TYPE + ".chat");
  944.  
  945.         private var _738950403channel:String;
  946.         private var _3381091nick:String;
  947.         private var _1714148973displayName:String;
  948.         private var _55126294timestamp:uint;
  949.         private var _bindingEventDispatcher:EventDispatcher;
  950.  
  951.         public function ZChat(_arg1:Object, _arg2:String=null){
  952.             _bindingEventDispatcher = new EventDispatcher(IEventDispatcher(this));
  953.             super(_arg1, ((_arg2) || (TYPE)));
  954.             channel = ((_arg1["__channel"]) || (_arg1["channel"]));
  955.             nick = ((_arg1["nick"]) || (_arg1["__nick"]));
  956.             displayName = ((_arg1["displayName"]) || (_arg1["name"]));
  957.         }
  958.         public function get channel():String{
  959.             return (this._738950403channel);
  960.         }
  961.         public function set channel(_arg1:String):void{
  962.             var _local2:Object = this._738950403channel;
  963.             if (_local2 !== _arg1){
  964.                 this._738950403channel = _arg1;
  965.                 if (this.hasEventListener("propertyChange")){
  966.                     this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "channel", _local2, _arg1));
  967.                 };
  968.             };
  969.         }
  970.         public function get nick():String{
  971.             return (this._3381091nick);
  972.         }
  973.         public function set nick(_arg1:String):void{
  974.             var _local2:Object = this._3381091nick;
  975.             if (_local2 !== _arg1){
  976.                 this._3381091nick = _arg1;
  977.                 if (this.hasEventListener("propertyChange")){
  978.                     this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "nick", _local2, _arg1));
  979.                 };
  980.             };
  981.         }
  982.         public function get displayName():String{
  983.             return (this._1714148973displayName);
  984.         }
  985.         public function set displayName(_arg1:String):void{
  986.             var _local2:Object = this._1714148973displayName;
  987.             if (_local2 !== _arg1){
  988.                 this._1714148973displayName = _arg1;
  989.                 if (this.hasEventListener("propertyChange")){
  990.                     this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "displayName", _local2, _arg1));
  991.                 };
  992.             };
  993.         }
  994.         public function get timestamp():uint{
  995.             return (this._55126294timestamp);
  996.         }
  997.         public function set timestamp(_arg1:uint):void{
  998.             var _local2:Object = this._55126294timestamp;
  999.             if (_local2 !== _arg1){
  1000.                 this._55126294timestamp = _arg1;
  1001.                 if (this.hasEventListener("propertyChange")){
  1002.                     this.dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "timestamp", _local2, _arg1));
  1003.                 };
  1004.             };
  1005.         }
  1006.         public function addEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false, _arg4:int=0, _arg5:Boolean=false):void{
  1007.             _bindingEventDispatcher.addEventListener(_arg1, _arg2, _arg3, _arg4, _arg5);
  1008.         }
  1009.         public function dispatchEvent(_arg1:Event):Boolean{
  1010.             return (_bindingEventDispatcher.dispatchEvent(_arg1));
  1011.         }
  1012.         public function hasEventListener(_arg1:String):Boolean{
  1013.             return (_bindingEventDispatcher.hasEventListener(_arg1));
  1014.         }
  1015.         public function removeEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false):void{
  1016.             _bindingEventDispatcher.removeEventListener(_arg1, _arg2, _arg3);
  1017.         }
  1018.         public function willTrigger(_arg1:String):Boolean{
  1019.             return (_bindingEventDispatcher.willTrigger(_arg1));
  1020.         }
  1021.  
  1022.     }
  1023. }//package zopim.events
  1024. package zopim.events {
  1025.  
  1026.     public class ZError extends ZEvent {
  1027.  
  1028.         public static const TYPE:String = (ZEvent.TYPE + ".error");
  1029.  
  1030.         public function ZError(_arg1:Object, _arg2:String=null){
  1031.             super(_arg1, ((_arg2) || (TYPE)));
  1032.         }
  1033.     }
  1034. }//package zopim.events
  1035. package zopim.events {
  1036.  
  1037.     public class ZBanned extends ZEvent {
  1038.  
  1039.         public static const TYPE:String = (ZEvent.TYPE + ".banned");
  1040.  
  1041.         public function ZBanned(_arg1:Object, _arg2:String=null){
  1042.             super(_arg1, ((_arg2) || (TYPE)));
  1043.         }
  1044.     }
  1045. }//package zopim.events
  1046. package zopim.events {
  1047.     import flash.events.*;
  1048.     import mx.utils.*;
  1049.  
  1050.     public class ZEvent extends Event {
  1051.  
  1052.         public static const TYPE:String = "zopim";
  1053.         public static const excludes:Array = ObjectUtil.getClassInfo(Event).properties.concat(["prototype", "json"]);
  1054.  
  1055.         public var json:Object;
  1056.         protected var _type:String;
  1057.  
  1058.         public function ZEvent(_arg1:Object, _arg2:String=null){
  1059.             var _local6:String;
  1060.             var _local7:String;
  1061.             super(((_arg2) || (TYPE)), false, false);
  1062.             _type = ((_arg2) || (TYPE));
  1063.             json = _arg1;
  1064.             var _local3:Array = ObjectUtil.getClassInfo(this, excludes).properties;
  1065.             var _local4:Class = this["constructor"];
  1066.             var _local5:Object = ((("OVERRIDES" in _local4)) ? _local4.OVERRIDES : {});
  1067.             for each (_local6 in _local3) {
  1068.                 _local7 = ((_local5[_local6]) || (_local6));
  1069.                 if (_arg1.hasOwnProperty(_local7)){
  1070.                     this[_local6] = _arg1[_local7];
  1071.                 } else {
  1072.                     this[_local6] = null;
  1073.                 };
  1074.             };
  1075.         }
  1076.         override public function clone():Event{
  1077.             return (new ZEvent(((json) || ({})), ((_type) || (TYPE))));
  1078.         }
  1079.  
  1080.     }
  1081. }//package zopim.events
  1082. package zopim.events {
  1083.  
  1084.     public class jsonMap {
  1085.  
  1086.         private static var _map:Object = {
  1087.             connection.error:ZErrorConnection,
  1088.             chat:ZChat
  1089.         };
  1090.  
  1091.         public function jsonMap():void{
  1092.             throw (new Error("This is a static class"));
  1093.         }
  1094.         public static function map(_arg1:String):Class{
  1095.             return (_map[_arg1]);
  1096.         }
  1097.         public static function addMapping(_arg1:String, _arg2:Class):void{
  1098.             _map[_arg1] = _arg2;
  1099.         }
  1100.         public static function jsonToEvent(_arg1:Object):ZEvent{
  1101.             var _local2:Class = _map[_arg1.__type];
  1102.             if (!_local2){
  1103.                 _local2 = ZEvent;
  1104.             };
  1105.             return (new _local2(_arg1));
  1106.         }
  1107.  
  1108.     }
  1109. }//package zopim.events
  1110. package zopim.utils {
  1111.     import flash.events.*;
  1112.     import flash.media.*;
  1113.     import flash.net.*;
  1114.     import flash.errors.*;
  1115.  
  1116.     public class SoundAlert {
  1117.  
  1118.         private static var url:String = "https://zopim.com/message.mp3";
  1119.         public static var SNAPSHOT:String = "https://zopim.com/camera.wav";
  1120.         private static var soundFactory:Sound;
  1121.         private static var sounds:Object = {};
  1122.  
  1123.         public function SoundAlert(){
  1124.             throw (new Error("Static class"));
  1125.         }
  1126.         private static function createSound(_arg1:String):Sound{
  1127.             var _local2:URLRequest = new URLRequest(_arg1);
  1128.             var _local3:Sound = new Sound();
  1129.             _local3.addEventListener(Event.COMPLETE, completeHandler, false, 0, true);
  1130.             _local3.addEventListener(Event.ID3, id3Handler, false, 0, true);
  1131.             _local3.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler, false, 0, true);
  1132.             _local3.load(_local2);
  1133.             return (_local3);
  1134.         }
  1135.         public static function init():void{
  1136.             soundFactory = createSound(url);
  1137.         }
  1138.         public static function play(_arg1:String=null, _arg2:Number=-1, _arg3:int=0):SoundChannel{
  1139.             var _local4:Sound;
  1140.             var _local5:SoundChannel;
  1141.             var _local6:SoundTransform;
  1142.             try {
  1143.                 if (!soundFactory){
  1144.                     init();
  1145.                 };
  1146.                 if (((_arg1) && (_arg1.length))){
  1147.                     if (!sounds[_arg1]){
  1148.                         sounds[_arg1] = createSound(_arg1);
  1149.                     };
  1150.                     _local4 = Sound(sounds[_arg1]);
  1151.                 } else {
  1152.                     _local4 = soundFactory;
  1153.                 };
  1154.                 _local5 = _local4.play(0, _arg3);
  1155.                 if (_arg2 >= 0){
  1156.                     _local6 = _local5.soundTransform;
  1157.                     _local6.volume = _arg2;
  1158.                     _local5.soundTransform = _local6;
  1159.                 };
  1160.                 return (_local5);
  1161.             } catch(e:Error) {
  1162.             };
  1163.             return (null);
  1164.         }
  1165.         private static function completeHandler(_arg1:Event):void{
  1166.         }
  1167.         private static function id3Handler(_arg1:Event):void{
  1168.         }
  1169.         private static function ioErrorHandler(_arg1:Event):void{
  1170.         }
  1171.  
  1172.     }
  1173. }//package zopim.utils
  1174. package zopim.net {
  1175.     import flash.events.*;
  1176.     import zopim.*;
  1177.     import flash.net.*;
  1178.     import flash.system.*;
  1179.  
  1180.     public class ZSharedObject {
  1181.  
  1182.         private static const EXPIRE:String = "_session_object_expire";
  1183.  
  1184.         private static var _isAllowed:Boolean;
  1185.  
  1186.         public var expiryDuration:uint;
  1187.         private var so:SharedObject;
  1188.  
  1189.         public function ZSharedObject(_arg1:String, _arg2:String=null, _arg3:uint=0, _arg4:Boolean=false){
  1190.             so = SharedObject.getLocal(_arg1, _arg2, _arg4);
  1191.             so.addEventListener(AsyncErrorEvent.ASYNC_ERROR, onAsyncErrorEvent, false, 0, true);
  1192.             so.addEventListener(NetStatusEvent.NET_STATUS, onNetStatusEvent, false, 0, true);
  1193.             if (_arg3){
  1194.                 this.expiryDuration = _arg3;
  1195.             };
  1196.         }
  1197.         public static function get isAllowed():Boolean{
  1198.             if ((_isAllowed is Boolean)){
  1199.                 return (_isAllowed);
  1200.             };
  1201.             var _local1:SharedObject = SharedObject.getLocal("zTest");
  1202.             if (!_local1.flush(1)){
  1203.                 ZConfig.traceTime("Your system does not allow SharedObject");
  1204.                 _isAllowed = false;
  1205.             } else {
  1206.                 ZConfig.traceTime("SharedObject not allowed, prompting user to enable it");
  1207.                 Security.showSettings(SecurityPanel.LOCAL_STORAGE);
  1208.                 _isAllowed = true;
  1209.             };
  1210.             return (_isAllowed);
  1211.         }
  1212.  
  1213.         public function flush(_arg1:int=0):void{
  1214.             var minDiskSpace:int = _arg1;
  1215.             if (expiryDuration){
  1216.                 so.data[EXPIRE] = new Date((new Date().getTime() + expiryDuration));
  1217.             };
  1218.             try {
  1219.                 if (!so.flush(minDiskSpace)){
  1220.                     printErrorMessage();
  1221.                 };
  1222.             } catch(e:Error) {
  1223.                 printErrorMessage();
  1224.             };
  1225.         }
  1226.         public function clear():void{
  1227.             so.clear();
  1228.         }
  1229.         public function get data():Object{
  1230.             var _local1:Date;
  1231.             var _local2:String;
  1232.             if (so.data[EXPIRE]){
  1233.                 _local1 = so.data[EXPIRE];
  1234.                 if (((_local1) && ((_local1 < new Date())))){
  1235.                     for (_local2 in so.data) {
  1236.                         delete so.data[_local2];
  1237.                     };
  1238.                     so.flush();
  1239.                 };
  1240.             };
  1241.             return (so.data);
  1242.         }
  1243.         private function onAsyncErrorEvent(_arg1:AsyncErrorEvent):void{
  1244.         }
  1245.         private function onNetStatusEvent(_arg1:NetStatusEvent):void{
  1246.         }
  1247.         private function printErrorMessage():void{
  1248.         }
  1249.  
  1250.     }
  1251. }//package zopim.net
  1252. package zopim.net {
  1253.     import flash.events.*;
  1254.     import zopim.*;
  1255.     import flash.utils.*;
  1256.     import flash.net.*;
  1257.  
  1258.     public class ZLocalConnection extends LocalConnection {
  1259.  
  1260.         private static const LC_KEY:String = "_localconnections";
  1261.  
  1262.         private static var _localConnections:Array = [];
  1263.         private static var _lcArray:Array;
  1264.         private static var so:ZSharedObject;
  1265.  
  1266.         private var _connectionName:String;
  1267.  
  1268.         public function ZLocalConnection(){
  1269.             allowDomain("*");
  1270.             addEventListener(AsyncErrorEvent.ASYNC_ERROR, onAsyncError, false, 0, true);
  1271.             addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError, false, 0, true);
  1272.             addEventListener(ErrorEvent.ERROR, onErrorEvent, false, 0, true);
  1273.             addEventListener(StatusEvent.STATUS, onStatusEvent, false, 0, true);
  1274.         }
  1275.         public static function get lcArray():Array{
  1276.             var _local1:String;
  1277.             if (_lcArray){
  1278.                 return (_lcArray);
  1279.             };
  1280.             if (!so){
  1281.                 return (null);
  1282.             };
  1283.             _lcArray = so.data[LC_KEY];
  1284.             if (!_lcArray){
  1285.                 _lcArray = (so.data[LC_KEY] = new Array());
  1286.                 so.flush();
  1287.             };
  1288.             for each (_local1 in _lcArray) {
  1289.                 _localConnections.push(new ZSendingLocalConnection(_local1));
  1290.             };
  1291.             return (_lcArray);
  1292.         }
  1293.         public static function init(_arg1:String):void{
  1294.             if ((so is ZSharedObject)){
  1295.                 return;
  1296.             };
  1297.             so = new ZSharedObject(_arg1, "/");
  1298.         }
  1299.         public static function removeLocalConnection(_arg1:String):void{
  1300.             if (!so){
  1301.                 return;
  1302.             };
  1303.             var _local2:int = lcArray.indexOf(_arg1);
  1304.             if (_local2 == -1){
  1305.                 return;
  1306.             };
  1307.             lcArray.splice(_local2, 1);
  1308.             _localConnections.splice(_local2, 1);
  1309.             so.flush();
  1310.         }
  1311.         public static function addLocalConnection(_arg1:String):void{
  1312.             if (((!(so)) || (!((lcArray.indexOf(_arg1) == -1))))){
  1313.                 return;
  1314.             };
  1315.             lcArray.push(_arg1);
  1316.             _localConnections.push(new ZSendingLocalConnection(_arg1));
  1317.             so.flush();
  1318.         }
  1319.  
  1320.         public function get connectionName():String{
  1321.             return (_connectionName);
  1322.         }
  1323.         private function onAsyncError(_arg1:AsyncErrorEvent):void{
  1324.             removeLocalConnection(connectionName);
  1325.         }
  1326.         private function onStatusEvent(_arg1:StatusEvent):void{
  1327.             if (_arg1.level == "error"){
  1328.                 removeLocalConnection(connectionName);
  1329.             };
  1330.         }
  1331.         private function onErrorEvent(_arg1:ErrorEvent):void{
  1332.         }
  1333.         private function onSecurityError(_arg1:SecurityErrorEvent):void{
  1334.         }
  1335.         override public function set client(_arg1:Object):void{
  1336.             var _local3:Object;
  1337.             var _local4:XMLList;
  1338.             var _local5:XML;
  1339.             var _local2:XML = describeType(_arg1);
  1340.             if (_local2.@isDynamic == true){
  1341.                 _local3 = _arg1;
  1342.             } else {
  1343.                 _local3 = new Object();
  1344.                 _local4 = _local2.method;
  1345.                 for each (_local5 in _local4) {
  1346.                     _local3[_local5.@name] = _arg1[_local5.@name];
  1347.                 };
  1348.             };
  1349.             _local3["addLocalConnection"] = addLocalConnection;
  1350.             _local3["removeLocalConnection"] = removeLocalConnection;
  1351.             super.client = _local3;
  1352.         }
  1353.         override public function connect(_arg1:String):void{
  1354.             var _connectionName:* = _arg1;
  1355.             try {
  1356.                 super.connect(_connectionName);
  1357.             } catch(e:Error) {
  1358.                 if ((e is TypeError)){
  1359.                 } else {
  1360.                     if ((e is ArgumentError)){
  1361.                     };
  1362.                 };
  1363.                 return;
  1364.             };
  1365.             this._connectionName = _connectionName;
  1366.             addLocalConnection(_connectionName);
  1367.             sendToAll(true, "addLocalConnection", _connectionName);
  1368.         }
  1369.         override public function close():void{
  1370.             try {
  1371.                 super.close();
  1372.             } catch(e:ArgumentError) {
  1373.                 ZConfig.traceTime("The LocalConnection instance is not connected, so it cannot be closed");
  1374.             };
  1375.             removeLocalConnection(connectionName);
  1376.             sendToAll(false, "removeLocalConnection", connectionName);
  1377.             _connectionName = null;
  1378.         }
  1379.         public function sendToAll(_arg1:Boolean, _arg2:String, ... _args):void{
  1380.             var _local6:String;
  1381.             var _local4:Array = ((_args) || ([]));
  1382.             if (!lcArray){
  1383.                 if (_arg1){
  1384.                     return;
  1385.                 };
  1386.                 _local4.unshift(connectionName, _arg2);
  1387.                 send.apply(this, _local4);
  1388.                 return;
  1389.             };
  1390.             var _local5:uint;
  1391.             while (_local5 < lcArray.length) {
  1392.                 _local6 = lcArray[_local5];
  1393.                 if ((((connectionName == _local6)) && (_arg1))){
  1394.                 } else {
  1395.                     _local4.unshift(_local6, _arg2);
  1396.                     (_localConnections[_local5] as ZSendingLocalConnection).send.apply(this, _local4);
  1397.                     _local4.splice(0, 2);
  1398.                 };
  1399.                 _local5++;
  1400.             };
  1401.         }
  1402.  
  1403.     }
  1404. }//package zopim.net
  1405.  
  1406. import flash.events.*;
  1407. import flash.net.*;
  1408.  
  1409. class ZSendingLocalConnection extends LocalConnection {
  1410.  
  1411.     public var connectionName:String = "";
  1412.  
  1413.     public function ZSendingLocalConnection(_arg1:String){
  1414.         if (_arg1){
  1415.             connectionName = _arg1;
  1416.         };
  1417.         super();
  1418.         addEventListener(AsyncErrorEvent.ASYNC_ERROR, onAsyncError, false, 0, true);
  1419.         addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError, false, 0, true);
  1420.         addEventListener(ErrorEvent.ERROR, onErrorEvent, false, 0, true);
  1421.         addEventListener(StatusEvent.STATUS, onStatusEvent, false, 0, true);
  1422.     }
  1423.     override public function send(_arg1:String, _arg2:String, ... _args):void{
  1424.         var name:* = _arg1;
  1425.         var methodName:* = _arg2;
  1426.         var parameters:* = _args;
  1427.         if (connectionName != name){
  1428.             return;
  1429.         };
  1430.         var argsArray:* = ((parameters) || (new Array()));
  1431.         argsArray.unshift(connectionName, methodName);
  1432.         try {
  1433.             super.send.apply(this, argsArray);
  1434.         } catch(e:Error) {
  1435.             if ((e is TypeError)){
  1436.             } else {
  1437.                 if ((e is ArgumentError)){
  1438.                 };
  1439.             };
  1440.             ZLocalConnection.removeLocalConnection(connectionName);
  1441.         };
  1442.     }
  1443.     private function onAsyncError(_arg1:AsyncErrorEvent):void{
  1444.         ZLocalConnection.removeLocalConnection(connectionName);
  1445.     }
  1446.     private function onStatusEvent(_arg1:StatusEvent):void{
  1447.         if (_arg1.level == "error"){
  1448.             ZLocalConnection.removeLocalConnection(connectionName);
  1449.         };
  1450.     }
  1451.     private function onErrorEvent(_arg1:ErrorEvent):void{
  1452.     }
  1453.     private function onSecurityError(_arg1:SecurityErrorEvent):void{
  1454.     }
  1455.  
  1456. }
  1457. package zopim.net {
  1458.     import flash.events.*;
  1459.     import zopim.events.*;
  1460.     import zopim.*;
  1461.     import flash.utils.*;
  1462.     import flash.net.*;
  1463.     import com.adobe.serialization.json.*;
  1464.     import flash.errors.*;
  1465.  
  1466.     public class _ZSocket extends Socket {
  1467.  
  1468.         private const DEFAULT_RECONNECT_DELAY:uint = 1000;
  1469.         private const MAX_RECONNECT_DELAY:uint = 256000;
  1470.  
  1471.         private var response:String = "";
  1472.         private var host:String = "";
  1473.         private var port:int = 0;
  1474.         private var reconnectDelay:uint = 1000;
  1475.         private var reconnectTimeoutId:uint = 0;
  1476.         protected var reconnecting:Boolean = false;
  1477.  
  1478.         public function _ZSocket(_arg1:String=null, _arg2:int=0){
  1479.             super(_arg1, _arg2);
  1480.             addEventListeners();
  1481.         }
  1482.         override public function connect(_arg1:String, _arg2:int):void{
  1483.             clearReconnectTimeout();
  1484.             if (((((((ZConfig.isSecure) || (connected))) || (!(_arg1)))) || (!(_arg2)))){
  1485.                 return;
  1486.             };
  1487.             ZConfig.traceTime(((("Connecting to " + _arg1) + ":") + _arg2));
  1488.             super.connect(_arg1, _arg2);
  1489.             this.host = _arg1;
  1490.             this.port = _arg2;
  1491.         }
  1492.         private function addEventListeners():void{
  1493.             addEventListener(Event.CLOSE, onError, false, 0, true);
  1494.             addEventListener(IOErrorEvent.IO_ERROR, onError, false, 0, true);
  1495.             addEventListener(SecurityErrorEvent.SECURITY_ERROR, onError, false, 0, true);
  1496.             addEventListener(Event.CONNECT, stopReconnecting, false, 0, true);
  1497.             addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler, false, 0, true);
  1498.         }
  1499.         public function send(_arg1:Object):void{
  1500.             var obj:* = _arg1;
  1501.             var str:* = JSON.encode(obj);
  1502.             str = (str + "\r\n");
  1503.             try {
  1504.                 ZConfig.traceTime(("socket sent: " + str));
  1505.                 writeUTFBytes(str);
  1506.                 flush();
  1507.             } catch(e:IOError) {
  1508.                 ZConfig.traceTime(e);
  1509.             };
  1510.         }
  1511.         protected function onError(_arg1:Event):void{
  1512.             ZConfig.traceTime(("_ZSocket error: " + _arg1.type));
  1513.             dispatchEvent(new ZSocketEvent(ZSocketEvent.SOCKET_ERROR, {
  1514.                 __status:"failed",
  1515.                 type:_arg1.type
  1516.             }));
  1517.             if (reconnecting){
  1518.                 _reconnect();
  1519.             };
  1520.         }
  1521.         protected function socketDataHandler(_arg1:ProgressEvent):void{
  1522.             var line:* = null;
  1523.             var json:* = null;
  1524.             var event:* = _arg1;
  1525.             var str:* = readUTFBytes(bytesAvailable);
  1526.             response = (response + str);
  1527.             var lines:* = response.split("\r\n");
  1528.             response = lines.pop();
  1529.             try {
  1530.                 while (lines.length > 0) {
  1531.                     line = lines.shift();
  1532.                     ZConfig.traceTime(("dispatching : " + line));
  1533.                     json = JSON.decode(line);
  1534.                     dispatchEvent(new ZSocketEvent(ZSocketEvent.SOCKET_DATA_READY, json));
  1535.                 };
  1536.             } catch(e:Error) {
  1537.                 ZConfig.traceTime(("bad json" + e));
  1538.             };
  1539.         }
  1540.         private function clearReconnectTimeout():void{
  1541.             clearTimeout(reconnectTimeoutId);
  1542.             reconnectTimeoutId = 0;
  1543.         }
  1544.         public function stopReconnecting(_arg1:Event=null):void{
  1545.             clearReconnectTimeout();
  1546.             reconnectDelay = DEFAULT_RECONNECT_DELAY;
  1547.             reconnecting = false;
  1548.         }
  1549.         public function reconnect():void{
  1550.             reconnectDelay = DEFAULT_RECONNECT_DELAY;
  1551.             reconnecting = true;
  1552.             _reconnect();
  1553.         }
  1554.         private function _reconnect():void{
  1555.             clearTimeout(reconnectTimeoutId);
  1556.             ZConfig.traceTime((("_ZSocket reconnecting in " + (reconnectDelay / 1000)) + "secs"));
  1557.             reconnectTimeoutId = setTimeout(connect, reconnectDelay, host, port);
  1558.             reconnectDelay = (reconnectDelay + (((reconnectDelay < MAX_RECONNECT_DELAY)) ? reconnectDelay : 0));
  1559.         }
  1560.  
  1561.     }
  1562. }//package zopim.net
  1563. package {
  1564.     import zopim.net.*;
  1565.     import flash.utils.*;
  1566.     import flash.external.*;
  1567.  
  1568.     public class SessionObject {
  1569.  
  1570.         private static const _jsSessionObject:String = "__$$__meshim__SessionInfo";
  1571.         private static const VOLATILE_SO:String = "Volatile_SO";
  1572.         private static const SESSION_SO:String = "Session_SO";
  1573.         private static const VOLATILE_EXPIRY_DURATION:uint = 120000;
  1574.         private static const DEFAULT_RENEWAL_PERIOD:uint = 30000;
  1575.  
  1576.         private static var keys:Object = {
  1577.             host:String,
  1578.             port:uint,
  1579.             channel:String,
  1580.             cId:String,
  1581.             nick:String,
  1582.             displayName:String,
  1583.             appearance:Object,
  1584.             position:String,
  1585.             settings:Object,
  1586.             _localConnections:Array,
  1587.             banned:Boolean,
  1588.             nossl:Boolean
  1589.         };
  1590.         private static var volatile_keys:Object = {
  1591.             unreadMsgs:uint,
  1592.             status:String,
  1593.             greeting:Object,
  1594.             agents:Array,
  1595.             cIds:Array,
  1596.             showStatusArea:Boolean,
  1597.             history:Array,
  1598.             _connectionMode:uint,
  1599.             windowPosition:Array,
  1600.             windowOpened:Boolean,
  1601.             sound:Boolean,
  1602.             email:String,
  1603.             hideBubble:Boolean,
  1604.             chatRequestFormDone:Boolean,
  1605.             disconnect:Boolean
  1606.         };
  1607.  
  1608.         private var persistentSO:ZSharedObject;
  1609.         private var volatileSO:ZSharedObject;
  1610.         private var localConnection:ZLocalConnection;
  1611.         private var tabIdentifier:String;
  1612.         private var accountKey:String;
  1613.  
  1614.         public function SessionObject(_arg1:String, _arg2:ZLocalConnection){
  1615.             this.accountKey = _arg1;
  1616.             this.tabIdentifier = tabIdentifier;
  1617.             init();
  1618.             if (((persistentSO) || (volatileSO))){
  1619.                 setJSSessionObject();
  1620.             };
  1621.             this.localConnection = _arg2;
  1622.             ExternalInterface.addCallback("saveSessionInfo", saveSOfromJS);
  1623.             ExternalInterface.addCallback("getSessionInfo", setJSSessionObject);
  1624.             ExternalInterface.addCallback("saveVariable", updateLocalConnections);
  1625.             setInterval(saveSOfromJS, DEFAULT_RENEWAL_PERIOD);
  1626.         }
  1627.         private function getCachedData(_arg1:Boolean=true):Object{
  1628.             var _local3:String;
  1629.             var _local2:Object = {};
  1630.             for (_local3 in volatileSO.data) {
  1631.                 if (((!(_arg1)) && ((_local3.charAt(0) == "_")))){
  1632.                 } else {
  1633.                     _local2[_local3] = volatileSO.data[_local3];
  1634.                 };
  1635.             };
  1636.             for (_local3 in persistentSO.data) {
  1637.                 if (((!(_arg1)) && ((_local3.charAt(0) == "_")))){
  1638.                 } else {
  1639.                     _local2[_local3] = persistentSO.data[_local3];
  1640.                 };
  1641.             };
  1642.             return (_local2);
  1643.         }
  1644.         public function get jsCachedData():Object{
  1645.             return (getCachedData(false));
  1646.         }
  1647.         public function get cachedData():Object{
  1648.             return (getCachedData());
  1649.         }
  1650.         private function saveSOfromJS():void{
  1651.             var _local1:Object = ExternalInterface.call("eval", _jsSessionObject);
  1652.             saveValues(_local1);
  1653.         }
  1654.         private function setJSSessionObject(_arg1:Object=null):void{
  1655.             _arg1 = ((_arg1) || (jsCachedData));
  1656.             ZClientController.encodeCharactersThatLameExternalInterfaceChokesOn(_arg1);
  1657.             ExternalInterface.call((_jsSessionObject + ".set"), _arg1);
  1658.         }
  1659.         public function saveValues(_arg1:Object):void{
  1660.             var _local4:String;
  1661.             if (!_arg1){
  1662.                 return;
  1663.             };
  1664.             var _local2:Boolean;
  1665.             var _local3:Boolean;
  1666.             for (_local4 in _arg1) {
  1667.                 if (((!((keys[_local4] == null))) && ((_arg1[_local4] is keys[_local4])))){
  1668.                     persistentSO.data[_local4] = _arg1[_local4];
  1669.                     _local3 = true;
  1670.                 } else {
  1671.                     if (((!((volatile_keys[_local4] == null))) && ((_arg1[_local4] is volatile_keys[_local4])))){
  1672.                         volatileSO.data[_local4] = _arg1[_local4];
  1673.                         _local2 = true;
  1674.                     };
  1675.                 };
  1676.             };
  1677.             if (_local3){
  1678.                 persistentSO.flush();
  1679.             };
  1680.             if (_local2){
  1681.                 volatileSO.flush();
  1682.             };
  1683.         }
  1684.         public function saveValue(_arg1:String, _arg2=null):void{
  1685.             if (keys[_arg1]){
  1686.                 persistentSO.data[_arg1] = _arg2;
  1687.                 persistentSO.flush();
  1688.             } else {
  1689.                 if (volatile_keys[_arg1]){
  1690.                     volatileSO.data[_arg1] = _arg2;
  1691.                     volatileSO.flush();
  1692.                 };
  1693.             };
  1694.         }
  1695.         public function updateVariable(_arg1:String, _arg2):void{
  1696.             saveValue(_arg1, _arg2);
  1697.             if (_arg1.charAt(0) == "_"){
  1698.                 return;
  1699.             };
  1700.             var _local3:Object = {};
  1701.             _local3[_arg1] = _arg2;
  1702.             setJSSessionObject(_local3);
  1703.         }
  1704.         private function updateLocalConnections(_arg1:String, _arg2, _arg3:Boolean=false, _arg4:Boolean=true):void{
  1705.             if (((((_arg4) && ((_arg1 in cachedData)))) && ((cachedData[_arg1] == _arg2)))){
  1706.                 return;
  1707.             };
  1708.             if (_arg3){
  1709.                 saveValue(_arg1, _arg2);
  1710.             };
  1711.             localConnection.sendToAll(_arg3, "updateVariable", _arg1, _arg2);
  1712.         }
  1713.         public function clear():void{
  1714.             persistentSO.clear();
  1715.             volatileSO.clear();
  1716.         }
  1717.         public function disconnect(_arg1:Object=null):void{
  1718.             if (_arg1){
  1719.                 saveValues(_arg1);
  1720.             } else {
  1721.                 saveSOfromJS();
  1722.             };
  1723.             localConnection.close();
  1724.         }
  1725.         private function init():void{
  1726.             persistentSO = new ZSharedObject((accountKey + SESSION_SO), "/");
  1727.             volatileSO = new ZSharedObject((accountKey + VOLATILE_SO), "/", VOLATILE_EXPIRY_DURATION);
  1728.             ZLocalConnection.init((accountKey + SESSION_SO));
  1729.         }
  1730.  
  1731.     }
  1732. }//package
  1733. package mx.core {
  1734.  
  1735.     public namespace mx_internal = "http://www.adobe.com/2006/flex/mx/internal";
  1736. }//package mx.core
  1737. package mx.core {
  1738.     import flash.display.*;
  1739.     import mx.managers.*;
  1740.  
  1741.     public interface IUIComponent extends IFlexDisplayObject {
  1742.  
  1743.         function get baselinePosition():Number;
  1744.         function get document():Object;
  1745.         function set document(_arg1:Object):void;
  1746.         function get enabled():Boolean;
  1747.         function set enabled(_arg1:Boolean):void;
  1748.         function get explicitHeight():Number;
  1749.         function set explicitHeight(_arg1:Number):void;
  1750.         function get explicitMaxHeight():Number;
  1751.         function get explicitMaxWidth():Number;
  1752.         function get explicitMinHeight():Number;
  1753.         function get explicitMinWidth():Number;
  1754.         function get explicitWidth():Number;
  1755.         function set explicitWidth(_arg1:Number):void;
  1756.         function get focusPane():Sprite;
  1757.         function set focusPane(_arg1:Sprite):void;
  1758.         function get includeInLayout():Boolean;
  1759.         function set includeInLayout(_arg1:Boolean):void;
  1760.         function get isPopUp():Boolean;
  1761.         function set isPopUp(_arg1:Boolean):void;
  1762.         function get maxHeight():Number;
  1763.         function get maxWidth():Number;
  1764.         function get measuredMinHeight():Number;
  1765.         function set measuredMinHeight(_arg1:Number):void;
  1766.         function get measuredMinWidth():Number;
  1767.         function set measuredMinWidth(_arg1:Number):void;
  1768.         function get minHeight():Number;
  1769.         function get minWidth():Number;
  1770.         function get owner():DisplayObjectContainer;
  1771.         function set owner(_arg1:DisplayObjectContainer):void;
  1772.         function get percentHeight():Number;
  1773.         function set percentHeight(_arg1:Number):void;
  1774.         function get percentWidth():Number;
  1775.         function set percentWidth(_arg1:Number):void;
  1776.         function get systemManager():ISystemManager;
  1777.         function set systemManager(_arg1:ISystemManager):void;
  1778.         function get tweeningProperties():Array;
  1779.         function set tweeningProperties(_arg1:Array):void;
  1780.         function initialize():void;
  1781.         function parentChanged(_arg1:DisplayObjectContainer):void;
  1782.         function getExplicitOrMeasuredWidth():Number;
  1783.         function getExplicitOrMeasuredHeight():Number;
  1784.         function setVisible(_arg1:Boolean, _arg2:Boolean=false):void;
  1785.         function owns(_arg1:DisplayObject):Boolean;
  1786.  
  1787.     }
  1788. }//package mx.core
  1789. package mx.core {
  1790.     import flash.utils.*;
  1791.     import flash.display.*;
  1792.     import __AS3__.vec.*;
  1793.  
  1794.     public interface IFlexModuleFactory {
  1795.  
  1796.         function get allowDomainsInNewRSLs():Boolean;
  1797.         function set allowDomainsInNewRSLs(_arg1:Boolean):void;
  1798.         function get allowInsecureDomainsInNewRSLs():Boolean;
  1799.         function set allowInsecureDomainsInNewRSLs(_arg1:Boolean):void;
  1800.         function get preloadedRSLs():Dictionary;
  1801.         function addPreloadedRSL(_arg1:LoaderInfo, _arg2:Vector.<RSLData>):void;
  1802.         function allowDomain(... _args):void;
  1803.         function allowInsecureDomain(... _args):void;
  1804.         function callInContext(_arg1:Function, _arg2:Object, _arg3:Array, _arg4:Boolean=true);
  1805.         function create(... _args):Object;
  1806.         function getImplementation(_arg1:String):Object;
  1807.         function info():Object;
  1808.         function registerImplementation(_arg1:String, _arg2:Object):void;
  1809.  
  1810.     }
  1811. }//package mx.core
  1812. package mx.core {
  1813.  
  1814.     public class RSLData {
  1815.  
  1816.         mx_internal static const VERSION:String = "4.6.0.23201";
  1817.  
  1818.         private var _applicationDomainTarget:String;
  1819.         private var _digest:String;
  1820.         private var _hashType:String;
  1821.         private var _isSigned:Boolean;
  1822.         private var _moduleFactory:IFlexModuleFactory;
  1823.         private var _policyFileURL:String;
  1824.         private var _rslURL:String;
  1825.         private var _verifyDigest:Boolean;
  1826.  
  1827.         public function RSLData(_arg1:String=null, _arg2:String=null, _arg3:String=null, _arg4:String=null, _arg5:Boolean=false, _arg6:Boolean=false, _arg7:String="default"){
  1828.             this._rslURL = _arg1;
  1829.             this._policyFileURL = _arg2;
  1830.             this._digest = _arg3;
  1831.             this._hashType = _arg4;
  1832.             this._isSigned = _arg5;
  1833.             this._verifyDigest = _arg6;
  1834.             this._applicationDomainTarget = _arg7;
  1835.             this._moduleFactory = this.moduleFactory;
  1836.         }
  1837.         public function get applicationDomainTarget():String{
  1838.             return (this._applicationDomainTarget);
  1839.         }
  1840.         public function get digest():String{
  1841.             return (this._digest);
  1842.         }
  1843.         public function get hashType():String{
  1844.             return (this._hashType);
  1845.         }
  1846.         public function get isSigned():Boolean{
  1847.             return (this._isSigned);
  1848.         }
  1849.         public function get moduleFactory():IFlexModuleFactory{
  1850.             return (this._moduleFactory);
  1851.         }
  1852.         public function set moduleFactory(_arg1:IFlexModuleFactory):void{
  1853.             this._moduleFactory = _arg1;
  1854.         }
  1855.         public function get policyFileURL():String{
  1856.             return (this._policyFileURL);
  1857.         }
  1858.         public function get rslURL():String{
  1859.             return (this._rslURL);
  1860.         }
  1861.         public function get verifyDigest():Boolean{
  1862.             return (this._verifyDigest);
  1863.         }
  1864.  
  1865.     }
  1866. }//package mx.core
  1867. package mx.core {
  1868.  
  1869.     public interface IUID {
  1870.  
  1871.         function get uid():String;
  1872.         function set uid(_arg1:String):void;
  1873.  
  1874.     }
  1875. }//package mx.core
  1876. package mx.core {
  1877.     import flash.display.*;
  1878.     import flash.geom.*;
  1879.  
  1880.     public interface IChildList {
  1881.  
  1882.         function get numChildren():int;
  1883.         function addChild(_arg1:DisplayObject):DisplayObject;
  1884.         function addChildAt(_arg1:DisplayObject, _arg2:int):DisplayObject;
  1885.         function removeChild(_arg1:DisplayObject):DisplayObject;
  1886.         function removeChildAt(_arg1:int):DisplayObject;
  1887.         function getChildAt(_arg1:int):DisplayObject;
  1888.         function getChildByName(_arg1:String):DisplayObject;
  1889.         function getChildIndex(_arg1:DisplayObject):int;
  1890.         function setChildIndex(_arg1:DisplayObject, _arg2:int):void;
  1891.         function getObjectsUnderPoint(_arg1:Point):Array;
  1892.         function contains(_arg1:DisplayObject):Boolean;
  1893.  
  1894.     }
  1895. }//package mx.core
  1896. package mx.core {
  1897.     import flash.events.*;
  1898.     import flash.display.*;
  1899.     import flash.geom.*;
  1900.     import flash.accessibility.*;
  1901.  
  1902.     public interface IFlexDisplayObject extends IBitmapDrawable, IEventDispatcher {
  1903.  
  1904.         function get root():DisplayObject;
  1905.         function get stage():Stage;
  1906.         function get name():String;
  1907.         function set name(_arg1:String):void;
  1908.         function get parent():DisplayObjectContainer;
  1909.         function get mask():DisplayObject;
  1910.         function set mask(_arg1:DisplayObject):void;
  1911.         function get visible():Boolean;
  1912.         function set visible(_arg1:Boolean):void;
  1913.         function get x():Number;
  1914.         function set x(_arg1:Number):void;
  1915.         function get y():Number;
  1916.         function set y(_arg1:Number):void;
  1917.         function get scaleX():Number;
  1918.         function set scaleX(_arg1:Number):void;
  1919.         function get scaleY():Number;
  1920.         function set scaleY(_arg1:Number):void;
  1921.         function get mouseX():Number;
  1922.         function get mouseY():Number;
  1923.         function get rotation():Number;
  1924.         function set rotation(_arg1:Number):void;
  1925.         function get alpha():Number;
  1926.         function set alpha(_arg1:Number):void;
  1927.         function get width():Number;
  1928.         function set width(_arg1:Number):void;
  1929.         function get height():Number;
  1930.         function set height(_arg1:Number):void;
  1931.         function get cacheAsBitmap():Boolean;
  1932.         function set cacheAsBitmap(_arg1:Boolean):void;
  1933.         function get opaqueBackground():Object;
  1934.         function set opaqueBackground(_arg1:Object):void;
  1935.         function get scrollRect():Rectangle;
  1936.         function set scrollRect(_arg1:Rectangle):void;
  1937.         function get filters():Array;
  1938.         function set filters(_arg1:Array):void;
  1939.         function get blendMode():String;
  1940.         function set blendMode(_arg1:String):void;
  1941.         function get transform():Transform;
  1942.         function set transform(_arg1:Transform):void;
  1943.         function get scale9Grid():Rectangle;
  1944.         function set scale9Grid(_arg1:Rectangle):void;
  1945.         function globalToLocal(_arg1:Point):Point;
  1946.         function localToGlobal(_arg1:Point):Point;
  1947.         function getBounds(_arg1:DisplayObject):Rectangle;
  1948.         function getRect(_arg1:DisplayObject):Rectangle;
  1949.         function get loaderInfo():LoaderInfo;
  1950.         function hitTestObject(_arg1:DisplayObject):Boolean;
  1951.         function hitTestPoint(_arg1:Number, _arg2:Number, _arg3:Boolean=false):Boolean;
  1952.         function get accessibilityProperties():AccessibilityProperties;
  1953.         function set accessibilityProperties(_arg1:AccessibilityProperties):void;
  1954.         function get measuredHeight():Number;
  1955.         function get measuredWidth():Number;
  1956.         function move(_arg1:Number, _arg2:Number):void;
  1957.         function setActualSize(_arg1:Number, _arg2:Number):void;
  1958.  
  1959.     }
  1960. }//package mx.core
  1961. package mx.core {
  1962.     import flash.events.*;
  1963.  
  1964.     public interface IPropertyChangeNotifier extends IEventDispatcher, IUID {
  1965.  
  1966.     }
  1967. }//package mx.core
  1968. package mx.managers {
  1969.     import flash.events.*;
  1970.     import flash.display.*;
  1971.     import flash.geom.*;
  1972.     import mx.core.*;
  1973.     import flash.text.*;
  1974.  
  1975.     public interface ISystemManager extends IEventDispatcher, IChildList, IFlexModuleFactory {
  1976.  
  1977.         function get cursorChildren():IChildList;
  1978.         function get document():Object;
  1979.         function set document(_arg1:Object):void;
  1980.         function get embeddedFontList():Object;
  1981.         function get focusPane():Sprite;
  1982.         function set focusPane(_arg1:Sprite):void;
  1983.         function get isProxy():Boolean;
  1984.         function get loaderInfo():LoaderInfo;
  1985.         function get numModalWindows():int;
  1986.         function set numModalWindows(_arg1:int):void;
  1987.         function get popUpChildren():IChildList;
  1988.         function get rawChildren():IChildList;
  1989.         function get screen():Rectangle;
  1990.         function get stage():Stage;
  1991.         function get toolTipChildren():IChildList;
  1992.         function get topLevelSystemManager():ISystemManager;
  1993.         function getDefinitionByName(_arg1:String):Object;
  1994.         function isTopLevel():Boolean;
  1995.         function isFontFaceEmbedded(_arg1:TextFormat):Boolean;
  1996.         function isTopLevelRoot():Boolean;
  1997.         function getTopLevelRoot():DisplayObject;
  1998.         function getSandboxRoot():DisplayObject;
  1999.         function getVisibleApplicationRect(_arg1:Rectangle=null, _arg2:Boolean=false):Rectangle;
  2000.         function deployMouseShields(_arg1:Boolean):void;
  2001.         function invalidateParentSizeAndDisplayList():void;
  2002.  
  2003.     }
  2004. }//package mx.managers
  2005. package mx.binding {
  2006.     import mx.events.*;
  2007.     import mx.core.*;
  2008.  
  2009.     public class BindabilityInfo {
  2010.  
  2011.         mx_internal static const VERSION:String = "4.6.0.23201";
  2012.         public static const BINDABLE:String = "Bindable";
  2013.         public static const MANAGED:String = "Managed";
  2014.         public static const CHANGE_EVENT:String = "ChangeEvent";
  2015.         public static const NON_COMMITTING_CHANGE_EVENT:String = "NonCommittingChangeEvent";
  2016.         public static const ACCESSOR:String = "accessor";
  2017.         public static const METHOD:String = "method";
  2018.  
  2019.         private var typeDescription:XML;
  2020.         private var classChangeEvents:Object;
  2021.         private var childChangeEvents:Object;
  2022.  
  2023.         public function BindabilityInfo(_arg1:XML){
  2024.             this.childChangeEvents = {};
  2025.             super();
  2026.             this.typeDescription = _arg1;
  2027.         }
  2028.         public function getChangeEvents(_arg1:String):Object{
  2029.             var childDesc:* = null;
  2030.             var numChildren:* = 0;
  2031.             var childName:* = _arg1;
  2032.             var changeEvents:* = this.childChangeEvents[childName];
  2033.             if (!changeEvents){
  2034.                 changeEvents = this.copyProps(this.getClassChangeEvents(), {});
  2035.                 childDesc = (this.typeDescription.accessor.(@name == childName) + this.typeDescription.method.(@name == childName));
  2036.                 numChildren = childDesc.length();
  2037.                 if (numChildren == 0){
  2038.                     if (!this.typeDescription.@dynamic){
  2039.                         trace((((("warning: no describeType entry for '" + childName) + "' on non-dynamic type '") + this.typeDescription.@name) + "'"));
  2040.                     };
  2041.                 } else {
  2042.                     if (numChildren > 1){
  2043.                         trace(((((("warning: multiple describeType entries for '" + childName) + "' on type '") + this.typeDescription.@name) + "':\n") + childDesc));
  2044.                     };
  2045.                     this.addBindabilityEvents(childDesc.metadata, changeEvents);
  2046.                 };
  2047.                 this.childChangeEvents[childName] = changeEvents;
  2048.             };
  2049.             return (changeEvents);
  2050.         }
  2051.         private function getClassChangeEvents():Object{
  2052.             if (!this.classChangeEvents){
  2053.                 this.classChangeEvents = {};
  2054.                 this.addBindabilityEvents(this.typeDescription.metadata, this.classChangeEvents);
  2055.                 if (this.typeDescription.metadata.(@name == MANAGED).length() > 0){
  2056.                     this.classChangeEvents[PropertyChangeEvent.PROPERTY_CHANGE] = true;
  2057.                 };
  2058.             };
  2059.             return (this.classChangeEvents);
  2060.         }
  2061.         private function addBindabilityEvents(_arg1:XMLList, _arg2:Object):void{
  2062.             var metadata:* = _arg1;
  2063.             var eventListObj:* = _arg2;
  2064.             this.addChangeEvents(metadata.(@name == BINDABLE), eventListObj, true);
  2065.             this.addChangeEvents(metadata.(@name == CHANGE_EVENT), eventListObj, true);
  2066.             this.addChangeEvents(metadata.(@name == NON_COMMITTING_CHANGE_EVENT), eventListObj, false);
  2067.         }
  2068.         private function addChangeEvents(_arg1:XMLList, _arg2:Object, _arg3:Boolean):void{
  2069.             var _local4:XML;
  2070.             var _local5:XMLList;
  2071.             var _local6:String;
  2072.             for each (_local4 in _arg1) {
  2073.                 _local5 = _local4.arg;
  2074.                 if (_local5.length() > 0){
  2075.                     _local6 = _local5[0].@value;
  2076.                     _arg2[_local6] = _arg3;
  2077.                 } else {
  2078.                     trace((("warning: unconverted Bindable metadata in class '" + this.typeDescription.@name) + "'"));
  2079.                 };
  2080.             };
  2081.         }
  2082.         private function copyProps(_arg1:Object, _arg2:Object):Object{
  2083.             var _local3:String;
  2084.             for (_local3 in _arg1) {
  2085.                 _arg2[_local3] = _arg1[_local3];
  2086.             };
  2087.             return (_arg2);
  2088.         }
  2089.  
  2090.     }
  2091. }//package mx.binding
  2092. package mx.events {
  2093.     import flash.events.*;
  2094.     import mx.core.*;
  2095.  
  2096.     public class PropertyChangeEvent extends Event {
  2097.  
  2098.         mx_internal static const VERSION:String = "4.6.0.23201";
  2099.         public static const PROPERTY_CHANGE:String = "propertyChange";
  2100.  
  2101.         public var kind:String;
  2102.         public var newValue:Object;
  2103.         public var oldValue:Object;
  2104.         public var property:Object;
  2105.         public var source:Object;
  2106.  
  2107.         public function PropertyChangeEvent(_arg1:String, _arg2:Boolean=false, _arg3:Boolean=false, _arg4:String=null, _arg5:Object=null, _arg6:Object=null, _arg7:Object=null, _arg8:Object=null){
  2108.             super(_arg1, _arg2, _arg3);
  2109.             this.kind = _arg4;
  2110.             this.property = _arg5;
  2111.             this.oldValue = _arg6;
  2112.             this.newValue = _arg7;
  2113.             this.source = _arg8;
  2114.         }
  2115.         public static function createUpdateEvent(_arg1:Object, _arg2:Object, _arg3:Object, _arg4:Object):PropertyChangeEvent{
  2116.             var _local5:PropertyChangeEvent = new PropertyChangeEvent(PROPERTY_CHANGE);
  2117.             _local5.kind = PropertyChangeEventKind.UPDATE;
  2118.             _local5.oldValue = _arg3;
  2119.             _local5.newValue = _arg4;
  2120.             _local5.source = _arg1;
  2121.             _local5.property = _arg2;
  2122.             return (_local5);
  2123.         }
  2124.  
  2125.         override public function clone():Event{
  2126.             return (new PropertyChangeEvent(type, bubbles, cancelable, this.kind, this.property, this.oldValue, this.newValue, this.source));
  2127.         }
  2128.  
  2129.     }
  2130. }//package mx.events
  2131. package mx.events {
  2132.     import flash.events.*;
  2133.     import mx.core.*;
  2134.  
  2135.     public class CollectionEvent extends Event {
  2136.  
  2137.         mx_internal static const VERSION:String = "4.6.0.23201";
  2138.         public static const COLLECTION_CHANGE:String = "collectionChange";
  2139.  
  2140.         public var kind:String;
  2141.         public var items:Array;
  2142.         public var location:int;
  2143.         public var oldLocation:int;
  2144.  
  2145.         public function CollectionEvent(_arg1:String, _arg2:Boolean=false, _arg3:Boolean=false, _arg4:String=null, _arg5:int=-1, _arg6:int=-1, _arg7:Array=null){
  2146.             super(_arg1, _arg2, _arg3);
  2147.             this.kind = _arg4;
  2148.             this.location = _arg5;
  2149.             this.oldLocation = _arg6;
  2150.             this.items = ((_arg7) ? _arg7 : []);
  2151.         }
  2152.         override public function toString():String{
  2153.             return (formatToString("CollectionEvent", "kind", "location", "oldLocation", "type", "bubbles", "cancelable", "eventPhase"));
  2154.         }
  2155.         override public function clone():Event{
  2156.             return (new CollectionEvent(type, bubbles, cancelable, this.kind, this.location, this.oldLocation, this.items));
  2157.         }
  2158.  
  2159.     }
  2160. }//package mx.events
  2161. package mx.events {
  2162.     import mx.core.*;
  2163.  
  2164.     public final class PropertyChangeEventKind {
  2165.  
  2166.         mx_internal static const VERSION:String = "4.6.0.23201";
  2167.         public static const UPDATE:String = "update";
  2168.         public static const DELETE:String = "delete";
  2169.  
  2170.     }
  2171. }//package mx.events
  2172. package mx.utils {
  2173.  
  2174.     public namespace object_proxy = "http://www.adobe.com/2006/actionscript/flash/objectproxy";
  2175. }//package mx.utils
  2176. package mx.utils {
  2177.     import flash.utils.*;
  2178.     import mx.core.*;
  2179.  
  2180.     public class XMLNotifier {
  2181.  
  2182.         mx_internal static const VERSION:String = "4.6.0.23201";
  2183.  
  2184.         private static var instance:XMLNotifier;
  2185.  
  2186.         public function XMLNotifier(_arg1:XMLNotifierSingleton){
  2187.         }
  2188.         public static function getInstance():XMLNotifier{
  2189.             if (!instance){
  2190.                 instance = new XMLNotifier(new XMLNotifierSingleton());
  2191.             };
  2192.             return (instance);
  2193.         }
  2194.         mx_internal static function initializeXMLForNotification():Function{
  2195.             var notificationFunction:* = function (_arg1:Object, _arg2:String, _arg3:Object, _arg4:Object, _arg5:Object):void{
  2196.                 var _local8:Object;
  2197.                 var _local7:Dictionary = arguments.callee.watched;
  2198.                 if (_local7 != null){
  2199.                     for (_local8 in _local7) {
  2200.                         IXMLNotifiable(_local8).xmlNotification(_arg1, _arg2, _arg3, _arg4, _arg5);
  2201.                     };
  2202.                 };
  2203.             };
  2204.             return (notificationFunction);
  2205.         }
  2206.  
  2207.         public function watchXML(_arg1:Object, _arg2:IXMLNotifiable, _arg3:String=null):void{
  2208.             var _local4:Object;
  2209.             var _local5:XML;
  2210.             var _local6:Object;
  2211.             var _local7:Dictionary;
  2212.             if ((((_arg1 is XMLList)) && ((_arg1.length() > 1)))){
  2213.                 for each (_local4 in _arg1) {
  2214.                     this.watchXML(_local4, _arg2, _arg3);
  2215.                 };
  2216.             } else {
  2217.                 _local5 = XML(_arg1);
  2218.                 _local6 = _local5.notification();
  2219.                 if (!(_local6 is Function)){
  2220.                     _local6 = initializeXMLForNotification();
  2221.                     _local5.setNotification((_local6 as Function));
  2222.                     if (((_arg3) && ((_local6["uid"] == null)))){
  2223.                         _local6["uid"] = _arg3;
  2224.                     };
  2225.                 };
  2226.                 if (_local6["watched"] == undefined){
  2227.                     _local7 = new Dictionary(true);
  2228.                     _local6["watched"] = _local7;
  2229.                 } else {
  2230.                     _local7 = _local6["watched"];
  2231.                 };
  2232.                 _local7[_arg2] = true;
  2233.             };
  2234.         }
  2235.         public function unwatchXML(_arg1:Object, _arg2:IXMLNotifiable):void{
  2236.             var _local3:Object;
  2237.             var _local4:XML;
  2238.             var _local5:Object;
  2239.             var _local6:Dictionary;
  2240.             if ((((_arg1 is XMLList)) && ((_arg1.length() > 1)))){
  2241.                 for each (_local3 in _arg1) {
  2242.                     this.unwatchXML(_local3, _arg2);
  2243.                 };
  2244.             } else {
  2245.                 _local4 = XML(_arg1);
  2246.                 _local5 = _local4.notification();
  2247.                 if (!(_local5 is Function)){
  2248.                     return;
  2249.                 };
  2250.                 if (_local5["watched"] != undefined){
  2251.                     _local6 = _local5["watched"];
  2252.                     delete _local6[_arg2];
  2253.                 };
  2254.             };
  2255.         }
  2256.  
  2257.     }
  2258. }//package mx.utils
  2259.  
  2260. class XMLNotifierSingleton {
  2261.  
  2262.     public function XMLNotifierSingleton(){
  2263.     }
  2264. }
  2265. package mx.utils {
  2266.     import flash.utils.*;
  2267.     import mx.core.*;
  2268.  
  2269.     public class UIDUtil {
  2270.  
  2271.         mx_internal static const VERSION:String = "4.6.0.23201";
  2272.         private static const ALPHA_CHAR_CODES:Array = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70];
  2273.  
  2274.         private static var uidDictionary:Dictionary = new Dictionary(true);
  2275.  
  2276.         public static function createUID():String{
  2277.             var _local3:int;
  2278.             var _local4:int;
  2279.             var _local1:Array = new Array(36);
  2280.             var _local2:int;
  2281.             _local3 = 0;
  2282.             while (_local3 < 8) {
  2283.                 var _temp1 = _local2;
  2284.                 _local2 = (_local2 + 1);
  2285.                 var _local7 = _temp1;
  2286.                 _local1[_local7] = ALPHA_CHAR_CODES[Math.floor((Math.random() * 16))];
  2287.                 _local3++;
  2288.             };
  2289.             _local3 = 0;
  2290.             while (_local3 < 3) {
  2291.                 var _temp2 = _local2;
  2292.                 _local2 = (_local2 + 1);
  2293.                 _local7 = _temp2;
  2294.                 _local1[_local7] = 45;
  2295.                 _local4 = 0;
  2296.                 while (_local4 < 4) {
  2297.                     var _temp3 = _local2;
  2298.                     _local2 = (_local2 + 1);
  2299.                     var _local8 = _temp3;
  2300.                     _local1[_local8] = ALPHA_CHAR_CODES[Math.floor((Math.random() * 16))];
  2301.                     _local4++;
  2302.                 };
  2303.                 _local3++;
  2304.             };
  2305.             var _temp4 = _local2;
  2306.             _local2 = (_local2 + 1);
  2307.             _local7 = _temp4;
  2308.             _local1[_local7] = 45;
  2309.             var _local5:Number = new Date().getTime();
  2310.             var _local6:String = ("0000000" + _local5.toString(16).toUpperCase()).substr(-8);
  2311.             _local3 = 0;
  2312.             while (_local3 < 8) {
  2313.                 var _temp5 = _local2;
  2314.                 _local2 = (_local2 + 1);
  2315.                 _local8 = _temp5;
  2316.                 _local1[_local8] = _local6.charCodeAt(_local3);
  2317.                 _local3++;
  2318.             };
  2319.             _local3 = 0;
  2320.             while (_local3 < 4) {
  2321.                 var _temp6 = _local2;
  2322.                 _local2 = (_local2 + 1);
  2323.                 _local8 = _temp6;
  2324.                 _local1[_local8] = ALPHA_CHAR_CODES[Math.floor((Math.random() * 16))];
  2325.                 _local3++;
  2326.             };
  2327.             return (String.fromCharCode.apply(null, _local1));
  2328.         }
  2329.         public static function fromByteArray(_arg1:ByteArray):String{
  2330.             var _local2:Array;
  2331.             var _local3:uint;
  2332.             var _local4:uint;
  2333.             var _local5:int;
  2334.             if (((((!((_arg1 == null))) && ((_arg1.length >= 16)))) && ((_arg1.bytesAvailable >= 16)))){
  2335.                 _local2 = new Array(36);
  2336.                 _local3 = 0;
  2337.                 _local4 = 0;
  2338.                 while (_local4 < 16) {
  2339.                     if ((((((((_local4 == 4)) || ((_local4 == 6)))) || ((_local4 == 8)))) || ((_local4 == 10)))){
  2340.                         var _temp1 = _local3;
  2341.                         _local3 = (_local3 + 1);
  2342.                         var _local6 = _temp1;
  2343.                         _local2[_local6] = 45;
  2344.                     };
  2345.                     _local5 = _arg1.readByte();
  2346.                     var _temp2 = _local3;
  2347.                     _local3 = (_local3 + 1);
  2348.                     _local6 = _temp2;
  2349.                     _local2[_local6] = ALPHA_CHAR_CODES[((_local5 & 240) >>> 4)];
  2350.                     var _temp3 = _local3;
  2351.                     _local3 = (_local3 + 1);
  2352.                     var _local7 = _temp3;
  2353.                     _local2[_local7] = ALPHA_CHAR_CODES[(_local5 & 15)];
  2354.                     _local4++;
  2355.                 };
  2356.                 return (String.fromCharCode.apply(null, _local2));
  2357.             };
  2358.             return (null);
  2359.         }
  2360.         public static function isUID(_arg1:String):Boolean{
  2361.             var _local2:uint;
  2362.             var _local3:Number;
  2363.             if (((!((_arg1 == null))) && ((_arg1.length == 36)))){
  2364.                 _local2 = 0;
  2365.                 while (_local2 < 36) {
  2366.                     _local3 = _arg1.charCodeAt(_local2);
  2367.                     if ((((((((_local2 == 8)) || ((_local2 == 13)))) || ((_local2 == 18)))) || ((_local2 == 23)))){
  2368.                         if (_local3 != 45){
  2369.                             return (false);
  2370.                         };
  2371.                     } else {
  2372.                         if ((((((_local3 < 48)) || ((_local3 > 70)))) || ((((_local3 > 57)) && ((_local3 < 65)))))){
  2373.                             return (false);
  2374.                         };
  2375.                     };
  2376.                     _local2++;
  2377.                 };
  2378.                 return (true);
  2379.             };
  2380.             return (false);
  2381.         }
  2382.         public static function toByteArray(_arg1:String):ByteArray{
  2383.             var _local2:ByteArray;
  2384.             var _local3:uint;
  2385.             var _local4:String;
  2386.             var _local5:uint;
  2387.             var _local6:uint;
  2388.             if (isUID(_arg1)){
  2389.                 _local2 = new ByteArray();
  2390.                 _local3 = 0;
  2391.                 while (_local3 < _arg1.length) {
  2392.                     _local4 = _arg1.charAt(_local3);
  2393.                     if (_local4 == "-"){
  2394.                     } else {
  2395.                         _local5 = getDigit(_local4);
  2396.                         _local3++;
  2397.                         _local6 = getDigit(_arg1.charAt(_local3));
  2398.                         _local2.writeByte((((_local5 << 4) | _local6) & 0xFF));
  2399.                     };
  2400.                     _local3++;
  2401.                 };
  2402.                 _local2.position = 0;
  2403.                 return (_local2);
  2404.             };
  2405.             return (null);
  2406.         }
  2407.         public static function getUID(_arg1:Object):String{
  2408.             var result:* = null;
  2409.             var xitem:* = null;
  2410.             var nodeKind:* = null;
  2411.             var notificationFunction:* = null;
  2412.             var item:* = _arg1;
  2413.             result = null;
  2414.             if (item == null){
  2415.                 return (result);
  2416.             };
  2417.             if ((item is IUID)){
  2418.                 result = IUID(item).uid;
  2419.                 if ((((result == null)) || ((result.length == 0)))){
  2420.                     result = createUID();
  2421.                     IUID(item).uid = result;
  2422.                 };
  2423.             } else {
  2424.                 if ((((item is IPropertyChangeNotifier)) && (!((item is IUIComponent))))){
  2425.                     result = IPropertyChangeNotifier(item).uid;
  2426.                     if ((((result == null)) || ((result.length == 0)))){
  2427.                         result = createUID();
  2428.                         IPropertyChangeNotifier(item).uid = result;
  2429.                     };
  2430.                 } else {
  2431.                     if ((item is String)){
  2432.                         return ((item as String));
  2433.                     };
  2434.                     try {
  2435.                         if ((((item is XMLList)) && ((item.length == 1)))){
  2436.                             item = item[0];
  2437.                         };
  2438.                         if ((item is XML)){
  2439.                             xitem = XML(item);
  2440.                             nodeKind = xitem.nodeKind();
  2441.                             if ((((nodeKind == "text")) || ((nodeKind == "attribute")))){
  2442.                                 return (xitem.toString());
  2443.                             };
  2444.                             notificationFunction = xitem.notification();
  2445.                             if (!(notificationFunction is Function)){
  2446.                                 notificationFunction = XMLNotifier.initializeXMLForNotification();
  2447.                                 xitem.setNotification(notificationFunction);
  2448.                             };
  2449.                             if (notificationFunction["uid"] == undefined){
  2450.                                 result = (notificationFunction["uid"] = createUID());
  2451.                             };
  2452.                             result = notificationFunction["uid"];
  2453.                         } else {
  2454.                             if (("mx_internal_uid" in item)){
  2455.                                 return (item.mx_internal_uid);
  2456.                             };
  2457.                             if (("uid" in item)){
  2458.                                 return (item.uid);
  2459.                             };
  2460.                             result = uidDictionary[item];
  2461.                             if (!result){
  2462.                                 result = createUID();
  2463.                                 try {
  2464.                                     item.mx_internal_uid = result;
  2465.                                 } catch(e:Error) {
  2466.                                     uidDictionary[item] = result;
  2467.                                 };
  2468.                             };
  2469.                         };
  2470.                     } catch(e:Error) {
  2471.                         result = item.toString();
  2472.                     };
  2473.                 };
  2474.             };
  2475.             return (result);
  2476.         }
  2477.         private static function getDigit(_arg1:String):uint{
  2478.             switch (_arg1){
  2479.                 case "A":
  2480.                 case "a":
  2481.                     return (10);
  2482.                 case "B":
  2483.                 case "b":
  2484.                     return (11);
  2485.                 case "C":
  2486.                 case "c":
  2487.                     return (12);
  2488.                 case "D":
  2489.                 case "d":
  2490.                     return (13);
  2491.                 case "E":
  2492.                 case "e":
  2493.                     return (14);
  2494.                 case "F":
  2495.                 case "f":
  2496.                     return (15);
  2497.                 default:
  2498.                     return (new uint(_arg1));
  2499.             };
  2500.         }
  2501.  
  2502.     }
  2503. }//package mx.utils
  2504. package mx.utils {
  2505.     import flash.utils.*;
  2506.  
  2507.     public class Base64Encoder {
  2508.  
  2509.         public static const CHARSET_UTF_8:String = "UTF-8";
  2510.         public static const MAX_BUFFER_SIZE:uint = 32767;
  2511.         private static const ESCAPE_CHAR_CODE:Number = 61;
  2512.         private static const ALPHABET_CHAR_CODES:Array = [65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47];
  2513.  
  2514.         public static var newLine:int = 10;
  2515.  
  2516.         public var insertNewLines:Boolean = true;
  2517.         private var _buffers:Array;
  2518.         private var _count:uint;
  2519.         private var _line:uint;
  2520.         private var _work:Array;
  2521.  
  2522.         public function Base64Encoder(){
  2523.             this._work = [0, 0, 0];
  2524.             super();
  2525.             this.reset();
  2526.         }
  2527.         public function drain():String{
  2528.             var _local3:Array;
  2529.             var _local1 = "";
  2530.             var _local2:uint;
  2531.             while (_local2 < this._buffers.length) {
  2532.                 _local3 = (this._buffers[_local2] as Array);
  2533.                 _local1 = (_local1 + String.fromCharCode.apply(null, _local3));
  2534.                 _local2++;
  2535.             };
  2536.             this._buffers = [];
  2537.             this._buffers.push([]);
  2538.             return (_local1);
  2539.         }
  2540.         public function encode(_arg1:String, _arg2:uint=0, _arg3:uint=0):void{
  2541.             if (_arg3 == 0){
  2542.                 _arg3 = _arg1.length;
  2543.             };
  2544.             var _local4:uint = _arg2;
  2545.             var _local5:uint = (_arg2 + _arg3);
  2546.             if (_local5 > _arg1.length){
  2547.                 _local5 = _arg1.length;
  2548.             };
  2549.             while (_local4 < _local5) {
  2550.                 this._work[this._count] = _arg1.charCodeAt(_local4);
  2551.                 this._count++;
  2552.                 if ((((this._count == this._work.length)) || (((_local5 - _local4) == 1)))){
  2553.                     this.encodeBlock();
  2554.                     this._count = 0;
  2555.                     this._work[0] = 0;
  2556.                     this._work[1] = 0;
  2557.                     this._work[2] = 0;
  2558.                 };
  2559.                 _local4++;
  2560.             };
  2561.         }
  2562.         public function encodeUTFBytes(_arg1:String):void{
  2563.             var _local2:ByteArray = new ByteArray();
  2564.             _local2.writeUTFBytes(_arg1);
  2565.             _local2.position = 0;
  2566.             this.encodeBytes(_local2);
  2567.         }
  2568.         public function encodeBytes(_arg1:ByteArray, _arg2:uint=0, _arg3:uint=0):void{
  2569.             if (_arg3 == 0){
  2570.                 _arg3 = _arg1.length;
  2571.             };
  2572.             var _local4:uint = _arg1.position;
  2573.             _arg1.position = _arg2;
  2574.             var _local5:uint = _arg2;
  2575.             var _local6:uint = (_arg2 + _arg3);
  2576.             if (_local6 > _arg1.length){
  2577.                 _local6 = _arg1.length;
  2578.             };
  2579.             while (_local5 < _local6) {
  2580.                 this._work[this._count] = _arg1[_local5];
  2581.                 this._count++;
  2582.                 if ((((this._count == this._work.length)) || (((_local6 - _local5) == 1)))){
  2583.                     this.encodeBlock();
  2584.                     this._count = 0;
  2585.                     this._work[0] = 0;
  2586.                     this._work[1] = 0;
  2587.                     this._work[2] = 0;
  2588.                 };
  2589.                 _local5++;
  2590.             };
  2591.             _arg1.position = _local4;
  2592.         }
  2593.         public function flush():String{
  2594.             if (this._count > 0){
  2595.                 this.encodeBlock();
  2596.             };
  2597.             var _local1:String = this.drain();
  2598.             this.reset();
  2599.             return (_local1);
  2600.         }
  2601.         public function reset():void{
  2602.             this._buffers = [];
  2603.             this._buffers.push([]);
  2604.             this._count = 0;
  2605.             this._line = 0;
  2606.             this._work[0] = 0;
  2607.             this._work[1] = 0;
  2608.             this._work[2] = 0;
  2609.         }
  2610.         public function toString():String{
  2611.             return (this.flush());
  2612.         }
  2613.         private function encodeBlock():void{
  2614.             var _local1:Array = (this._buffers[(this._buffers.length - 1)] as Array);
  2615.             if (_local1.length >= MAX_BUFFER_SIZE){
  2616.                 _local1 = [];
  2617.                 this._buffers.push(_local1);
  2618.             };
  2619.             _local1.push(ALPHABET_CHAR_CODES[((this._work[0] & 0xFF) >> 2)]);
  2620.             _local1.push(ALPHABET_CHAR_CODES[(((this._work[0] & 3) << 4) | ((this._work[1] & 240) >> 4))]);
  2621.             if (this._count > 1){
  2622.                 _local1.push(ALPHABET_CHAR_CODES[(((this._work[1] & 15) << 2) | ((this._work[2] & 192) >> 6))]);
  2623.             } else {
  2624.                 _local1.push(ESCAPE_CHAR_CODE);
  2625.             };
  2626.             if (this._count > 2){
  2627.                 _local1.push(ALPHABET_CHAR_CODES[(this._work[2] & 63)]);
  2628.             } else {
  2629.                 _local1.push(ESCAPE_CHAR_CODE);
  2630.             };
  2631.             if (this.insertNewLines){
  2632.                 if ((this._line = (this._line + 4)) == 76){
  2633.                     _local1.push(newLine);
  2634.                     this._line = 0;
  2635.                 };
  2636.             };
  2637.         }
  2638.  
  2639.     }
  2640. }//package mx.utils
  2641. package mx.utils {
  2642.     import flash.utils.*;
  2643.     import mx.core.*;
  2644.     import mx.binding.*;
  2645.  
  2646.     public class DescribeTypeCache {
  2647.  
  2648.         mx_internal static const VERSION:String = "4.6.0.23201";
  2649.  
  2650.         private static var typeCache:Object = {};
  2651.         private static var cacheHandlers:Object = {};
  2652.  
  2653.         public static function describeType(_arg1):DescribeTypeCacheRecord{
  2654.             var _local2:String;
  2655.             var _local3:String;
  2656.             var _local4:XML;
  2657.             var _local5:DescribeTypeCacheRecord;
  2658.             if ((_arg1 is String)){
  2659.                 _local2 = _arg1;
  2660.                 _local3 = _local2;
  2661.             } else {
  2662.                 _local2 = getQualifiedClassName(_arg1);
  2663.                 _local3 = _local2;
  2664.             };
  2665.             if ((_arg1 is Class)){
  2666.                 _local3 = (_local3 + "$");
  2667.             };
  2668.             if ((_local3 in typeCache)){
  2669.                 return (typeCache[_local3]);
  2670.             };
  2671.             if ((_arg1 is String)){
  2672.                 try {
  2673.                     _arg1 = getDefinitionByName(_arg1);
  2674.                 } catch(error:ReferenceError) {
  2675.                 };
  2676.             };
  2677.             _local4 = describeType(_arg1);
  2678.             _local5 = new DescribeTypeCacheRecord();
  2679.             _local5.typeDescription = _local4;
  2680.             _local5.typeName = _local2;
  2681.             typeCache[_local3] = _local5;
  2682.             return (_local5);
  2683.         }
  2684.         public static function registerCacheHandler(_arg1:String, _arg2:Function):void{
  2685.             cacheHandlers[_arg1] = _arg2;
  2686.         }
  2687.         static function extractValue(_arg1:String, _arg2:DescribeTypeCacheRecord){
  2688.             if ((_arg1 in cacheHandlers)){
  2689.                 return (cacheHandlers[_arg1](_arg2));
  2690.             };
  2691.             return (undefined);
  2692.         }
  2693.         private static function bindabilityInfoHandler(_arg1:DescribeTypeCacheRecord){
  2694.             return (new BindabilityInfo(_arg1.typeDescription));
  2695.         }
  2696.  
  2697.         registerCacheHandler("bindabilityInfo", bindabilityInfoHandler);
  2698.     }
  2699. }//package mx.utils
  2700. package mx.utils {
  2701.  
  2702.     public interface IXMLNotifiable {
  2703.  
  2704.         function xmlNotification(_arg1:Object, _arg2:String, _arg3:Object, _arg4:Object, _arg5:Object):void;
  2705.  
  2706.     }
  2707. }//package mx.utils
  2708. package mx.utils {
  2709.     import flash.utils.*;
  2710.     import mx.collections.*;
  2711.     import mx.core.*;
  2712.     import flash.xml.*;
  2713.  
  2714.     public class ObjectUtil {
  2715.  
  2716.         mx_internal static const VERSION:String = "4.6.0.23201";
  2717.  
  2718.         private static var defaultToStringExcludes:Array = ["password", "credentials"];
  2719.         private static var refCount:int = 0;
  2720.         private static var CLASS_INFO_CACHE:Object = {};
  2721.  
  2722.         public static function compare(_arg1:Object, _arg2:Object, _arg3:int=-1):int{
  2723.             return (internalCompare(_arg1, _arg2, 0, _arg3, new Dictionary(true)));
  2724.         }
  2725.         public static function copy(_arg1:Object):Object{
  2726.             var _local2:ByteArray = new ByteArray();
  2727.             _local2.writeObject(_arg1);
  2728.             _local2.position = 0;
  2729.             var _local3:Object = _local2.readObject();
  2730.             return (_local3);
  2731.         }
  2732.         public static function clone(_arg1:Object):Object{
  2733.             var _local2:Object = copy(_arg1);
  2734.             cloneInternal(_local2, _arg1);
  2735.             return (_local2);
  2736.         }
  2737.         private static function cloneInternal(_arg1:Object, _arg2:Object):void{
  2738.             var _local4:Object;
  2739.             var _local5:*;
  2740.             if (((_arg2) && (_arg2.hasOwnProperty("uid")))){
  2741.                 _arg1.uid = _arg2.uid;
  2742.             };
  2743.             var _local3:Object = getClassInfo(_arg2);
  2744.             for each (_local5 in _local3.properties) {
  2745.                 _local4 = _arg2[_local5];
  2746.                 if (((_local4) && (_local4.hasOwnProperty("uid")))){
  2747.                     cloneInternal(_arg1[_local5], _local4);
  2748.                 };
  2749.             };
  2750.         }
  2751.         public static function isSimple(_arg1:Object):Boolean{
  2752.             var _local2 = typeof(_arg1);
  2753.             switch (_local2){
  2754.                 case "number":
  2755.                 case "string":
  2756.                 case "boolean":
  2757.                     return (true);
  2758.                 case "object":
  2759.                     return ((((_arg1 is Date)) || ((_arg1 is Array))));
  2760.             };
  2761.             return (false);
  2762.         }
  2763.         public static function numericCompare(_arg1:Number, _arg2:Number):int{
  2764.             if (((isNaN(_arg1)) && (isNaN(_arg2)))){
  2765.                 return (0);
  2766.             };
  2767.             if (isNaN(_arg1)){
  2768.                 return (1);
  2769.             };
  2770.             if (isNaN(_arg2)){
  2771.                 return (-1);
  2772.             };
  2773.             if (_arg1 < _arg2){
  2774.                 return (-1);
  2775.             };
  2776.             if (_arg1 > _arg2){
  2777.                 return (1);
  2778.             };
  2779.             return (0);
  2780.         }
  2781.         public static function stringCompare(_arg1:String, _arg2:String, _arg3:Boolean=false):int{
  2782.             if ((((_arg1 == null)) && ((_arg2 == null)))){
  2783.                 return (0);
  2784.             };
  2785.             if (_arg1 == null){
  2786.                 return (1);
  2787.             };
  2788.             if (_arg2 == null){
  2789.                 return (-1);
  2790.             };
  2791.             if (_arg3){
  2792.                 _arg1 = _arg1.toLocaleLowerCase();
  2793.                 _arg2 = _arg2.toLocaleLowerCase();
  2794.             };
  2795.             var _local4:int = _arg1.localeCompare(_arg2);
  2796.             if (_local4 < -1){
  2797.                 _local4 = -1;
  2798.             } else {
  2799.                 if (_local4 > 1){
  2800.                     _local4 = 1;
  2801.                 };
  2802.             };
  2803.             return (_local4);
  2804.         }
  2805.         public static function dateCompare(_arg1:Date, _arg2:Date):int{
  2806.             if ((((_arg1 == null)) && ((_arg2 == null)))){
  2807.                 return (0);
  2808.             };
  2809.             if (_arg1 == null){
  2810.                 return (1);
  2811.             };
  2812.             if (_arg2 == null){
  2813.                 return (-1);
  2814.             };
  2815.             var _local3:Number = _arg1.getTime();
  2816.             var _local4:Number = _arg2.getTime();
  2817.             if (_local3 < _local4){
  2818.                 return (-1);
  2819.             };
  2820.             if (_local3 > _local4){
  2821.                 return (1);
  2822.             };
  2823.             return (0);
  2824.         }
  2825.         public static function toString(_arg1:Object, _arg2:Array=null, _arg3:Array=null):String{
  2826.             if (_arg3 == null){
  2827.                 _arg3 = defaultToStringExcludes;
  2828.             };
  2829.             refCount = 0;
  2830.             return (internalToString(_arg1, 0, null, _arg2, _arg3));
  2831.         }
  2832.         private static function internalToString(_arg1:Object, _arg2:int=0, _arg3:Dictionary=null, _arg4:Array=null, _arg5:Array=null):String{
  2833.             var str:* = null;
  2834.             var classInfo:* = null;
  2835.             var properties:* = null;
  2836.             var isArray:* = false;
  2837.             var isDict:* = false;
  2838.             var prop:* = undefined;
  2839.             var j:* = 0;
  2840.             var id:* = null;
  2841.             var value:* = _arg1;
  2842.             var indent:int = _arg2;
  2843.             var refs = _arg3;
  2844.             var namespaceURIs = _arg4;
  2845.             var exclude = _arg5;
  2846.             var type:* = (((value == null)) ? "null" : typeof(value));
  2847.             switch (type){
  2848.                 case "boolean":
  2849.                 case "number":
  2850.                     return (value.toString());
  2851.                 case "string":
  2852.                     return ((("\"" + value.toString()) + "\""));
  2853.                 case "object":
  2854.                     if ((value is Date)){
  2855.                         return (value.toString());
  2856.                     };
  2857.                     if ((value is XMLNode)){
  2858.                         return (value.toString());
  2859.                     };
  2860.                     if ((value is Class)){
  2861.                         return ((("(" + getQualifiedClassName(value)) + ")"));
  2862.                     };
  2863.                     classInfo = getClassInfo(value, exclude, {
  2864.                         includeReadOnly:true,
  2865.                         uris:namespaceURIs
  2866.                     });
  2867.                     properties = classInfo.properties;
  2868.                     str = (("(" + classInfo.name) + ")");
  2869.                     if (refs == null){
  2870.                         refs = new Dictionary(true);
  2871.                     };
  2872.                     try {
  2873.                         id = refs[value];
  2874.                         if (id != null){
  2875.                             str = (str + ("#" + int(id)));
  2876.                             return (str);
  2877.                         };
  2878.                     } catch(e:Error) {
  2879.                         return (String(value));
  2880.                     };
  2881.                     if (value != null){
  2882.                         str = (str + ("#" + refCount.toString()));
  2883.                         refs[value] = refCount;
  2884.                         refCount++;
  2885.                     };
  2886.                     isArray = (value is Array);
  2887.                     isDict = (value is Dictionary);
  2888.                     indent = (indent + 2);
  2889.                     j = 0;
  2890.                     while (j < properties.length) {
  2891.                         str = newline(str, indent);
  2892.                         prop = properties[j];
  2893.                         if (isArray){
  2894.                             str = (str + "[");
  2895.                         } else {
  2896.                             if (isDict){
  2897.                                 str = (str + "{");
  2898.                             };
  2899.                         };
  2900.                         if (isDict){
  2901.                             str = (str + internalToString(prop, indent, refs, namespaceURIs, exclude));
  2902.                         } else {
  2903.                             str = (str + prop.toString());
  2904.                         };
  2905.                         if (isArray){
  2906.                             str = (str + "] ");
  2907.                         } else {
  2908.                             if (isDict){
  2909.                                 str = (str + "} = ");
  2910.                             } else {
  2911.                                 str = (str + " = ");
  2912.                             };
  2913.                         };
  2914.                         try {
  2915.                             str = (str + internalToString(value[prop], indent, refs, namespaceURIs, exclude));
  2916.                         } catch(e:Error) {
  2917.                             str = (str + "?");
  2918.                         };
  2919.                         j = (j + 1);
  2920.                     };
  2921.                     indent = (indent - 2);
  2922.                     return (str);
  2923.                 case "xml":
  2924.                     return (value.toXMLString());
  2925.                 default:
  2926.                     return ((("(" + type) + ")"));
  2927.             };
  2928.         }
  2929.         private static function newline(_arg1:String, _arg2:int=0):String{
  2930.             var _local3:String = _arg1;
  2931.             _local3 = (_local3 + "\n");
  2932.             var _local4:int;
  2933.             while (_local4 < _arg2) {
  2934.                 _local3 = (_local3 + " ");
  2935.                 _local4++;
  2936.             };
  2937.             return (_local3);
  2938.         }
  2939.         private static function internalCompare(_arg1:Object, _arg2:Object, _arg3:int, _arg4:int, _arg5:Dictionary):int{
  2940.             var _local9:int;
  2941.             var _local10:Object;
  2942.             var _local11:Object;
  2943.             var _local12:Array;
  2944.             var _local13:Array;
  2945.             var _local14:Boolean;
  2946.             var _local15:QName;
  2947.             var _local16:Object;
  2948.             var _local17:Object;
  2949.             var _local18:int;
  2950.             if ((((_arg1 == null)) && ((_arg2 == null)))){
  2951.                 return (0);
  2952.             };
  2953.             if (_arg1 == null){
  2954.                 return (1);
  2955.             };
  2956.             if (_arg2 == null){
  2957.                 return (-1);
  2958.             };
  2959.             if ((_arg1 is ObjectProxy)){
  2960.                 _arg1 = ObjectProxy(_arg1).object_proxy::object;
  2961.             };
  2962.             if ((_arg2 is ObjectProxy)){
  2963.                 _arg2 = ObjectProxy(_arg2).object_proxy::object;
  2964.             };
  2965.             var _local6 = typeof(_arg1);
  2966.             var _local7 = typeof(_arg2);
  2967.             var _local8:int;
  2968.             if (_local6 == _local7){
  2969.                 switch (_local6){
  2970.                     case "boolean":
  2971.                         _local8 = numericCompare(Number(_arg1), Number(_arg2));
  2972.                         break;
  2973.                     case "number":
  2974.                         _local8 = numericCompare((_arg1 as Number), (_arg2 as Number));
  2975.                         break;
  2976.                     case "string":
  2977.                         _local8 = stringCompare((_arg1 as String), (_arg2 as String));
  2978.                         break;
  2979.                     case "object":
  2980.                         _local9 = (((_arg4 > 0)) ? (_arg4 - 1) : _arg4);
  2981.                         _local10 = getRef(_arg1, _arg5);
  2982.                         _local11 = getRef(_arg2, _arg5);
  2983.                         if (_local10 == _local11){
  2984.                             return (0);
  2985.                         };
  2986.                         _arg5[_local11] = _local10;
  2987.                         if (((!((_arg4 == -1))) && ((_arg3 > _arg4)))){
  2988.                             _local8 = stringCompare(_arg1.toString(), _arg2.toString());
  2989.                         } else {
  2990.                             if ((((_arg1 is Array)) && ((_arg2 is Array)))){
  2991.                                 _local8 = arrayCompare((_arg1 as Array), (_arg2 as Array), _arg3, _arg4, _arg5);
  2992.                             } else {
  2993.                                 if ((((_arg1 is Date)) && ((_arg2 is Date)))){
  2994.                                     _local8 = dateCompare((_arg1 as Date), (_arg2 as Date));
  2995.                                 } else {
  2996.                                     if ((((_arg1 is IList)) && ((_arg2 is IList)))){
  2997.                                         _local8 = listCompare((_arg1 as IList), (_arg2 as IList), _arg3, _arg4, _arg5);
  2998.                                     } else {
  2999.                                         if ((((_arg1 is ByteArray)) && ((_arg2 is ByteArray)))){
  3000.                                             _local8 = byteArrayCompare((_arg1 as ByteArray), (_arg2 as ByteArray));
  3001.                                         } else {
  3002.                                             if (getQualifiedClassName(_arg1) == getQualifiedClassName(_arg2)){
  3003.                                                 _local12 = getClassInfo(_arg1).properties;
  3004.                                                 _local14 = isDynamicObject(_arg1);
  3005.                                                 if (_local14){
  3006.                                                     _local13 = getClassInfo(_arg2).properties;
  3007.                                                     _local8 = arrayCompare(_local12, _local13, _arg3, _local9, _arg5);
  3008.                                                     if (_local8 != 0){
  3009.                                                         return (_local8);
  3010.                                                     };
  3011.                                                 };
  3012.                                                 _local18 = 0;
  3013.                                                 while (_local18 < _local12.length) {
  3014.                                                     _local15 = _local12[_local18];
  3015.                                                     _local16 = _arg1[_local15];
  3016.                                                     _local17 = _arg2[_local15];
  3017.                                                     _local8 = internalCompare(_local16, _local17, (_arg3 + 1), _local9, _arg5);
  3018.                                                     if (_local8 != 0){
  3019.                                                         return (_local8);
  3020.                                                     };
  3021.                                                     _local18++;
  3022.                                                 };
  3023.                                             } else {
  3024.                                                 return (1);
  3025.                                             };
  3026.                                         };
  3027.                                     };
  3028.                                 };
  3029.                             };
  3030.                         };
  3031.                         break;
  3032.                 };
  3033.             } else {
  3034.                 return (stringCompare(_local6, _local7));
  3035.             };
  3036.             return (_local8);
  3037.         }
  3038.         public static function getClassInfo(_arg1:Object, _arg2:Array=null, _arg3:Object=null):Object{
  3039.             var n:* = 0;
  3040.             var i:* = 0;
  3041.             var result:* = null;
  3042.             var cacheKey:* = null;
  3043.             var className:* = null;
  3044.             var classAlias:* = null;
  3045.             var properties:* = null;
  3046.             var prop:* = null;
  3047.             var metadataInfo:* = null;
  3048.             var classInfo:* = null;
  3049.             var numericIndex:* = false;
  3050.             var key:* = undefined;
  3051.             var p:* = null;
  3052.             var pi:* = NaN;
  3053.             var uris:* = null;
  3054.             var uri:* = null;
  3055.             var qName:* = null;
  3056.             var j:* = 0;
  3057.             var obj:* = _arg1;
  3058.             var excludes = _arg2;
  3059.             var options = _arg3;
  3060.             if ((obj is ObjectProxy)){
  3061.                 obj = ObjectProxy(obj).object_proxy::object;
  3062.             };
  3063.             if (options == null){
  3064.                 options = {
  3065.                     includeReadOnly:true,
  3066.                     uris:null,
  3067.                     includeTransient:true
  3068.                 };
  3069.             };
  3070.             var propertyNames:* = [];
  3071.             var dynamic:* = false;
  3072.             if (typeof(obj) == "xml"){
  3073.                 className = "XML";
  3074.                 properties = obj.text();
  3075.                 if (properties.length()){
  3076.                     propertyNames.push("*");
  3077.                 };
  3078.                 properties = obj.attributes();
  3079.             } else {
  3080.                 classInfo = DescribeTypeCache.describeType(obj).typeDescription;
  3081.                 className = classInfo.@name.toString();
  3082.                 classAlias = classInfo.@alias.toString();
  3083.                 dynamic = (classInfo.@isDynamic.toString() == "true");
  3084.                 if (options.includeReadOnly){
  3085.                     properties = (classInfo..accessor.(@access != "writeonly") + classInfo..variable);
  3086.                 } else {
  3087.                     properties = (classInfo..accessor.(@access == "readwrite") + classInfo..variable);
  3088.                 };
  3089.                 numericIndex = false;
  3090.             };
  3091.             if (!dynamic){
  3092.                 cacheKey = getCacheKey(obj, excludes, options);
  3093.                 result = CLASS_INFO_CACHE[cacheKey];
  3094.                 if (result != null){
  3095.                     return (result);
  3096.                 };
  3097.             };
  3098.             result = {};
  3099.             result["name"] = className;
  3100.             result["alias"] = classAlias;
  3101.             result["properties"] = propertyNames;
  3102.             result["dynamic"] = dynamic;
  3103.             var _local5 = recordMetadata(properties);
  3104.             metadataInfo = _local5;
  3105.             result["metadata"] = _local5;
  3106.             var excludeObject:* = {};
  3107.             if (excludes){
  3108.                 n = excludes.length;
  3109.                 i = 0;
  3110.                 while (i < n) {
  3111.                     excludeObject[excludes[i]] = 1;
  3112.                     i = (i + 1);
  3113.                 };
  3114.             };
  3115.             var isArray:* = (className == "Array");
  3116.             var isDict:* = (className == "flash.utils::Dictionary");
  3117.             if (isDict){
  3118.                 for (key in obj) {
  3119.                     propertyNames.push(key);
  3120.                 };
  3121.             } else {
  3122.                 if (dynamic){
  3123.                     for (p in obj) {
  3124.                         if (excludeObject[p] != 1){
  3125.                             if (isArray){
  3126.                                 pi = parseInt(p);
  3127.                                 if (isNaN(pi)){
  3128.                                     propertyNames.push(new QName("", p));
  3129.                                 } else {
  3130.                                     propertyNames.push(pi);
  3131.                                 };
  3132.                             } else {
  3133.                                 propertyNames.push(new QName("", p));
  3134.                             };
  3135.                         };
  3136.                     };
  3137.                     numericIndex = ((isArray) && (!(isNaN(Number(p)))));
  3138.                 };
  3139.             };
  3140.             if (((((isArray) || (isDict))) || ((className == "Object")))){
  3141.             } else {
  3142.                 if (className == "XML"){
  3143.                     n = properties.length();
  3144.                     i = 0;
  3145.                     while (i < n) {
  3146.                         p = properties[i].name();
  3147.                         if (excludeObject[p] != 1){
  3148.                             propertyNames.push(new QName("", ("@" + p)));
  3149.                         };
  3150.                         i = (i + 1);
  3151.                     };
  3152.                 } else {
  3153.                     n = properties.length();
  3154.                     uris = options.uris;
  3155.                     i = 0;
  3156.                     while (i < n) {
  3157.                         prop = properties[i];
  3158.                         p = prop.@name.toString();
  3159.                         uri = prop.@uri.toString();
  3160.                         if (excludeObject[p] == 1){
  3161.                         } else {
  3162.                             if (((!(options.includeTransient)) && (internalHasMetadata(metadataInfo, p, "Transient")))){
  3163.                             } else {
  3164.                                 if (uris != null){
  3165.                                     if ((((uris.length == 1)) && ((uris[0] == "*")))){
  3166.                                         qName = new QName(uri, p);
  3167.                                         try {
  3168.                                             obj[qName];
  3169.                                             propertyNames.push();
  3170.                                         } catch(e:Error) {
  3171.                                         };
  3172.                                     } else {
  3173.                                         j = 0;
  3174.                                         while (j < uris.length) {
  3175.                                             uri = uris[j];
  3176.                                             if (prop.@uri.toString() == uri){
  3177.                                                 qName = new QName(uri, p);
  3178.                                                 try {
  3179.                                                     obj[qName];
  3180.                                                     propertyNames.push(qName);
  3181.                                                 } catch(e:Error) {
  3182.                                                 };
  3183.                                             };
  3184.                                             j = (j + 1);
  3185.                                         };
  3186.                                     };
  3187.                                 } else {
  3188.                                     if (uri.length == 0){
  3189.                                         qName = new QName(uri, p);
  3190.                                         try {
  3191.                                             obj[qName];
  3192.                                             propertyNames.push(qName);
  3193.                                         } catch(e:Error) {
  3194.                                         };
  3195.                                     };
  3196.                                 };
  3197.                             };
  3198.                         };
  3199.                         i = (i + 1);
  3200.                     };
  3201.                 };
  3202.             };
  3203.             propertyNames.sort((Array.CASEINSENSITIVE | ((numericIndex) ? Array.NUMERIC : 0)));
  3204.             if (!isDict){
  3205.                 i = 0;
  3206.                 while (i < (propertyNames.length - 1)) {
  3207.                     if (propertyNames[i].toString() == propertyNames[(i + 1)].toString()){
  3208.                         propertyNames.splice(i, 1);
  3209.                         i = (i - 1);
  3210.                     };
  3211.                     i = (i + 1);
  3212.                 };
  3213.             };
  3214.             if (!dynamic){
  3215.                 cacheKey = getCacheKey(obj, excludes, options);
  3216.                 CLASS_INFO_CACHE[cacheKey] = result;
  3217.             };
  3218.             return (result);
  3219.         }
  3220.         public static function hasMetadata(_arg1:Object, _arg2:String, _arg3:String, _arg4:Array=null, _arg5:Object=null):Boolean{
  3221.             var _local6:Object = getClassInfo(_arg1, _arg4, _arg5);
  3222.             var _local7:Object = _local6["metadata"];
  3223.             return (internalHasMetadata(_local7, _arg2, _arg3));
  3224.         }
  3225.         public static function isDynamicObject(_arg1:Object):Boolean{
  3226.             var obj:* = _arg1;
  3227.             try {
  3228.                 obj["wootHackwoot"];
  3229.             } catch(e:Error) {
  3230.                 return (false);
  3231.             };
  3232.             return (true);
  3233.         }
  3234.         private static function internalHasMetadata(_arg1:Object, _arg2:String, _arg3:String):Boolean{
  3235.             var _local4:Object;
  3236.             if (_arg1 != null){
  3237.                 _local4 = _arg1[_arg2];
  3238.                 if (_local4 != null){
  3239.                     if (_local4[_arg3] != null){
  3240.                         return (true);
  3241.                     };
  3242.                 };
  3243.             };
  3244.             return (false);
  3245.         }
  3246.         private static function recordMetadata(_arg1:XMLList):Object{
  3247.             var _local3:XML;
  3248.             var _local4:String;
  3249.             var _local5:XMLList;
  3250.             var _local6:Object;
  3251.             var _local7:XML;
  3252.             var _local8:String;
  3253.             var _local9:XMLList;
  3254.             var _local10:Object;
  3255.             var _local11:XML;
  3256.             var _local12:Object;
  3257.             var _local13:String;
  3258.             var _local14:String;
  3259.             var _local15:Array;
  3260.             var _local2:Object;
  3261.             try {
  3262.                 for each (_local3 in _arg1) {
  3263.                     _local4 = _local3.attribute("name").toString();
  3264.                     _local5 = _local3.metadata;
  3265.                     if (_local5.length() > 0){
  3266.                         if (_local2 == null){
  3267.                             _local2 = {};
  3268.                         };
  3269.                         _local6 = {};
  3270.                         _local2[_local4] = _local6;
  3271.                         for each (_local7 in _local5) {
  3272.                             _local8 = _local7.attribute("name").toString();
  3273.                             _local9 = _local7.arg;
  3274.                             _local10 = {};
  3275.                             for each (_local11 in _local9) {
  3276.                                 _local13 = _local11.attribute("key").toString();
  3277.                                 if (_local13 != null){
  3278.                                     _local14 = _local11.attribute("value").toString();
  3279.                                     _local10[_local13] = _local14;
  3280.                                 };
  3281.                             };
  3282.                             _local12 = _local6[_local8];
  3283.                             if (_local12 != null){
  3284.                                 if ((_local12 is Array)){
  3285.                                     _local15 = (_local12 as Array);
  3286.                                 } else {
  3287.                                     _local15 = [_local12];
  3288.                                     delete _local6[_local8];
  3289.                                 };
  3290.                                 _local15.push(_local10);
  3291.                                 _local12 = _local15;
  3292.                             } else {
  3293.                                 _local12 = _local10;
  3294.                             };
  3295.                             _local6[_local8] = _local12;
  3296.                         };
  3297.                     };
  3298.                 };
  3299.             } catch(e:Error) {
  3300.             };
  3301.             return (_local2);
  3302.         }
  3303.         private static function getCacheKey(_arg1:Object, _arg2:Array=null, _arg3:Object=null):String{
  3304.             var _local5:uint;
  3305.             var _local6:String;
  3306.             var _local7:String;
  3307.             var _local8:String;
  3308.             var _local4:String = getQualifiedClassName(_arg1);
  3309.             if (_arg2 != null){
  3310.                 _local5 = 0;
  3311.                 while (_local5 < _arg2.length) {
  3312.                     _local6 = (_arg2[_local5] as String);
  3313.                     if (_local6 != null){
  3314.                         _local4 = (_local4 + _local6);
  3315.                     };
  3316.                     _local5++;
  3317.                 };
  3318.             };
  3319.             if (_arg3 != null){
  3320.                 for (_local7 in _arg3) {
  3321.                     _local4 = (_local4 + _local7);
  3322.                     _local8 = (_arg3[_local7] as String);
  3323.                     if (_local8 != null){
  3324.                         _local4 = (_local4 + _local8);
  3325.                     };
  3326.                 };
  3327.             };
  3328.             return (_local4);
  3329.         }
  3330.         private static function arrayCompare(_arg1:Array, _arg2:Array, _arg3:int, _arg4:int, _arg5:Dictionary):int{
  3331.             var _local7:Object;
  3332.             var _local6:int;
  3333.             if (_arg1.length != _arg2.length){
  3334.                 if (_arg1.length < _arg2.length){
  3335.                     _local6 = -1;
  3336.                 } else {
  3337.                     _local6 = 1;
  3338.                 };
  3339.             } else {
  3340.                 for (_local7 in _arg1) {
  3341.                     if (_arg2.hasOwnProperty(_local7)){
  3342.                         _local6 = internalCompare(_arg1[_local7], _arg2[_local7], _arg3, _arg4, _arg5);
  3343.                         if (_local6 != 0){
  3344.                             return (_local6);
  3345.                         };
  3346.                     } else {
  3347.                         return (-1);
  3348.                     };
  3349.                 };
  3350.                 for (_local7 in _arg2) {
  3351.                     if (!_arg1.hasOwnProperty(_local7)){
  3352.                         return (1);
  3353.                     };
  3354.                 };
  3355.             };
  3356.             return (_local6);
  3357.         }
  3358.         private static function byteArrayCompare(_arg1:ByteArray, _arg2:ByteArray):int{
  3359.             var _local4:int;
  3360.             var _local3:int;
  3361.             if (_arg1 == _arg2){
  3362.                 return (_local3);
  3363.             };
  3364.             if (_arg1.length != _arg2.length){
  3365.                 if (_arg1.length < _arg2.length){
  3366.                     _local3 = -1;
  3367.                 } else {
  3368.                     _local3 = 1;
  3369.                 };
  3370.             } else {
  3371.                 _local4 = 0;
  3372.                 while (_local4 < _arg1.length) {
  3373.                     _local3 = numericCompare(_arg1[_local4], _arg2[_local4]);
  3374.                     if (_local3 != 0){
  3375.                         _local4 = _arg1.length;
  3376.                     };
  3377.                     _local4++;
  3378.                 };
  3379.             };
  3380.             return (_local3);
  3381.         }
  3382.         private static function listCompare(_arg1:IList, _arg2:IList, _arg3:int, _arg4:int, _arg5:Dictionary):int{
  3383.             var _local7:int;
  3384.             var _local6:int;
  3385.             if (_arg1.length != _arg2.length){
  3386.                 if (_arg1.length < _arg2.length){
  3387.                     _local6 = -1;
  3388.                 } else {
  3389.                     _local6 = 1;
  3390.                 };
  3391.             } else {
  3392.                 _local7 = 0;
  3393.                 while (_local7 < _arg1.length) {
  3394.                     _local6 = internalCompare(_arg1.getItemAt(_local7), _arg2.getItemAt(_local7), (_arg3 + 1), _arg4, _arg5);
  3395.                     if (_local6 != 0){
  3396.                         _local7 = _arg1.length;
  3397.                     };
  3398.                     _local7++;
  3399.                 };
  3400.             };
  3401.             return (_local6);
  3402.         }
  3403.         private static function getRef(_arg1:Object, _arg2:Dictionary):Object{
  3404.             var _local3:Object = _arg2[_arg1];
  3405.             while (((_local3) && (!((_local3 == _arg2[_local3]))))) {
  3406.                 _local3 = _arg2[_local3];
  3407.             };
  3408.             if (!_local3){
  3409.                 _local3 = _arg1;
  3410.             };
  3411.             if (_local3 != _arg2[_arg1]){
  3412.                 _arg2[_arg1] = _local3;
  3413.             };
  3414.             return (_local3);
  3415.         }
  3416.  
  3417.     }
  3418. }//package mx.utils
  3419. package mx.utils {
  3420.     import flash.events.*;
  3421.     import flash.utils.*;
  3422.     import mx.events.*;
  3423.     import mx.core.*;
  3424.  
  3425.     public dynamic class ObjectProxy extends Proxy implements IExternalizable, IPropertyChangeNotifier {
  3426.  
  3427.         protected var dispatcher:EventDispatcher;
  3428.         protected var notifiers:Object;
  3429.         protected var proxyClass:Class;
  3430.         protected var propertyList:Array;
  3431.         private var _proxyLevel:int;
  3432.         private var _item:Object;
  3433.         private var _type:QName;
  3434.         private var _id:String;
  3435.  
  3436.         public function ObjectProxy(_arg1:Object=null, _arg2:String=null, _arg3:int=-1){
  3437.             this.proxyClass = ObjectProxy;
  3438.             super();
  3439.             if (!_arg1){
  3440.                 _arg1 = {};
  3441.             };
  3442.             this._item = _arg1;
  3443.             this._proxyLevel = _arg3;
  3444.             this.notifiers = {};
  3445.             this.dispatcher = new EventDispatcher(this);
  3446.             if (_arg2){
  3447.                 this._id = _arg2;
  3448.             };
  3449.         }
  3450.         object_proxy function get object():Object{
  3451.             return (this._item);
  3452.         }
  3453.         object_proxy function get type():QName{
  3454.             return (this._type);
  3455.         }
  3456.         object_proxy function set type(_arg1:QName):void{
  3457.             this._type = _arg1;
  3458.         }
  3459.         public function get uid():String{
  3460.             if (this._id === null){
  3461.                 this._id = UIDUtil.createUID();
  3462.             };
  3463.             return (this._id);
  3464.         }
  3465.         public function set uid(_arg1:String):void{
  3466.             this._id = _arg1;
  3467.         }
  3468.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function getProperty(_arg1){
  3469.             var _local2:*;
  3470.             if (this.notifiers[_arg1.toString()]){
  3471.                 return (this.notifiers[_arg1]);
  3472.             };
  3473.             _local2 = this._item[_arg1];
  3474.             if (_local2){
  3475.                 if ((((this._proxyLevel == 0)) || (ObjectUtil.isSimple(_local2)))){
  3476.                     return (_local2);
  3477.                 };
  3478.                 _local2 = this.getComplexProperty(_arg1, _local2);
  3479.             };
  3480.             return (_local2);
  3481.         }
  3482.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function callProperty(_arg1, ... _args){
  3483.             return (this._item[_arg1].apply(this._item, _args));
  3484.         }
  3485.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function deleteProperty(_arg1):Boolean{
  3486.             var _local5:PropertyChangeEvent;
  3487.             var _local2:IPropertyChangeNotifier = IPropertyChangeNotifier(this.notifiers[_arg1]);
  3488.             if (_local2){
  3489.                 _local2.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE, this.propertyChangeHandler);
  3490.                 delete this.notifiers[_arg1];
  3491.             };
  3492.             var _local3:* = this._item[_arg1];
  3493.             var _local4 = delete this._item[_arg1];
  3494.             if (this.dispatcher.hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE)){
  3495.                 _local5 = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  3496.                 _local5.kind = PropertyChangeEventKind.DELETE;
  3497.                 _local5.property = _arg1;
  3498.                 _local5.oldValue = _local3;
  3499.                 _local5.source = this;
  3500.                 this.dispatcher.dispatchEvent(_local5);
  3501.             };
  3502.             return (_local4);
  3503.         }
  3504.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function hasProperty(_arg1):Boolean{
  3505.             return ((_arg1 in this._item));
  3506.         }
  3507.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextName(_arg1:int):String{
  3508.             return (this.propertyList[(_arg1 - 1)]);
  3509.         }
  3510.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextNameIndex(_arg1:int):int{
  3511.             if (_arg1 == 0){
  3512.                 this.setupPropertyList();
  3513.             };
  3514.             if (_arg1 < this.propertyList.length){
  3515.                 return ((_arg1 + 1));
  3516.             };
  3517.             return (0);
  3518.         }
  3519.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextValue(_arg1:int){
  3520.             return (this._item[this.propertyList[(_arg1 - 1)]]);
  3521.         }
  3522.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function setProperty(_arg1, _arg2):void{
  3523.             var _local4:IPropertyChangeNotifier;
  3524.             var _local5:PropertyChangeEvent;
  3525.             var _local3:* = this._item[_arg1];
  3526.             if (_local3 !== _arg2){
  3527.                 this._item[_arg1] = _arg2;
  3528.                 _local4 = IPropertyChangeNotifier(this.notifiers[_arg1]);
  3529.                 if (_local4){
  3530.                     _local4.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE, this.propertyChangeHandler);
  3531.                     delete this.notifiers[_arg1];
  3532.                 };
  3533.                 if (this.dispatcher.hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE)){
  3534.                     if ((_arg1 is QName)){
  3535.                         _arg1 = QName(_arg1).localName;
  3536.                     };
  3537.                     _local5 = PropertyChangeEvent.createUpdateEvent(this, _arg1.toString(), _local3, _arg2);
  3538.                     this.dispatcher.dispatchEvent(_local5);
  3539.                 };
  3540.             };
  3541.         }
  3542.         object_proxy function getComplexProperty(_arg1, _arg2){
  3543.             if ((_arg2 is IPropertyChangeNotifier)){
  3544.                 _arg2.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, this.propertyChangeHandler);
  3545.                 this.notifiers[_arg1] = _arg2;
  3546.                 return (_arg2);
  3547.             };
  3548.             if (getQualifiedClassName(_arg2) == "Object"){
  3549.                 _arg2 = new this.proxyClass(this._item[_arg1], null, (((this._proxyLevel > 0)) ? (this._proxyLevel - 1) : this._proxyLevel));
  3550.                 _arg2.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, this.propertyChangeHandler);
  3551.                 this.notifiers[_arg1] = _arg2;
  3552.                 return (_arg2);
  3553.             };
  3554.             return (_arg2);
  3555.         }
  3556.         public function readExternal(_arg1:IDataInput):void{
  3557.             var _local2:Object = _arg1.readObject();
  3558.             this._item = _local2;
  3559.         }
  3560.         public function writeExternal(_arg1:IDataOutput):void{
  3561.             _arg1.writeObject(this._item);
  3562.         }
  3563.         public function addEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false, _arg4:int=0, _arg5:Boolean=false):void{
  3564.             this.dispatcher.addEventListener(_arg1, _arg2, _arg3, _arg4, _arg5);
  3565.         }
  3566.         public function removeEventListener(_arg1:String, _arg2:Function, _arg3:Boolean=false):void{
  3567.             this.dispatcher.removeEventListener(_arg1, _arg2, _arg3);
  3568.         }
  3569.         public function dispatchEvent(_arg1:Event):Boolean{
  3570.             return (this.dispatcher.dispatchEvent(_arg1));
  3571.         }
  3572.         public function hasEventListener(_arg1:String):Boolean{
  3573.             return (this.dispatcher.hasEventListener(_arg1));
  3574.         }
  3575.         public function willTrigger(_arg1:String):Boolean{
  3576.             return (this.dispatcher.willTrigger(_arg1));
  3577.         }
  3578.         public function propertyChangeHandler(_arg1:PropertyChangeEvent):void{
  3579.             this.dispatcher.dispatchEvent(_arg1);
  3580.         }
  3581.         protected function setupPropertyList():void{
  3582.             var _local1:String;
  3583.             if (getQualifiedClassName(this._item) == "Object"){
  3584.                 this.propertyList = [];
  3585.                 for (_local1 in this._item) {
  3586.                     this.propertyList.push(_local1);
  3587.                 };
  3588.             } else {
  3589.                 this.propertyList = ObjectUtil.getClassInfo(this._item, null, {
  3590.                     includeReadOnly:true,
  3591.                     uris:["*"]
  3592.                 }).properties;
  3593.             };
  3594.         }
  3595.  
  3596.     }
  3597. }//package mx.utils
  3598. package mx.utils {
  3599.     import flash.utils.*;
  3600.  
  3601.     public dynamic class DescribeTypeCacheRecord extends Proxy {
  3602.  
  3603.         private var cache:Object;
  3604.         public var typeDescription:XML;
  3605.         public var typeName:String;
  3606.  
  3607.         public function DescribeTypeCacheRecord(){
  3608.             this.cache = {};
  3609.             super();
  3610.         }
  3611.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function getProperty(_arg1){
  3612.             var _local2:* = this.cache[_arg1];
  3613.             if (_local2 === undefined){
  3614.                 _local2 = DescribeTypeCache.extractValue(_arg1, this);
  3615.                 this.cache[_arg1] = _local2;
  3616.             };
  3617.             return (_local2);
  3618.         }
  3619.         override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function hasProperty(_arg1):Boolean{
  3620.             if ((_arg1 in this.cache)){
  3621.                 return (true);
  3622.             };
  3623.             var _local2:* = DescribeTypeCache.extractValue(_arg1, this);
  3624.             if (_local2 === undefined){
  3625.                 return (false);
  3626.             };
  3627.             this.cache[_arg1] = _local2;
  3628.             return (true);
  3629.         }
  3630.  
  3631.     }
  3632. }//package mx.utils
  3633. package mx.collections {
  3634.     import flash.events.*;
  3635.  
  3636.     public interface IList extends IEventDispatcher {
  3637.  
  3638.         function get length():int;
  3639.         function addItem(_arg1:Object):void;
  3640.         function addItemAt(_arg1:Object, _arg2:int):void;
  3641.         function getItemAt(_arg1:int, _arg2:int=0):Object;
  3642.         function getItemIndex(_arg1:Object):int;
  3643.         function itemUpdated(_arg1:Object, _arg2:Object=null, _arg3:Object=null, _arg4:Object=null):void;
  3644.         function removeAll():void;
  3645.         function removeItemAt(_arg1:int):Object;
  3646.         function setItemAt(_arg1:Object, _arg2:int):Object;
  3647.         function toArray():Array;
  3648.  
  3649.     }
  3650. }//package mx.collections
  3651. package {
  3652.     import zopim.net.*;
  3653.     import zopim.*;
  3654.     import flash.display.*;
  3655.     import zopim.utils.*;
  3656.     import flash.system.*;
  3657.     import flash.external.*;
  3658.  
  3659.     public class ZClientController extends Sprite {
  3660.  
  3661.         private var socket:ZClientSocket;
  3662.         private var sessionObject:SessionObject;
  3663.         private var localConnection:ZLocalConnection;
  3664.  
  3665.         public function ZClientController(){
  3666.             Security.allowDomain("*");
  3667.             Security.allowInsecureDomain("*");
  3668.             ZConfig.init(ZConfig.ZCLIENT_CONFIG);
  3669.             localConnection = new ZLocalConnection();
  3670.             sessionObject = new SessionObject(ZConfig.accountKey, localConnection);
  3671.             socket = new ZClientSocket(dispatchToJS, sessionObject);
  3672.             initLocalConnection();
  3673.             addExternalInterfaceCallbacks();
  3674.             socket.initSocket();
  3675.         }
  3676.         public static function encodeCharactersThatLameExternalInterfaceChokesOn(_arg1:Object):void{
  3677.             var _local2:String;
  3678.             for (_local2 in _arg1) {
  3679.                 if ((_arg1[_local2] is String)){
  3680.                     _arg1[_local2] = _arg1[_local2].replace(/\\/g, "\\\\");
  3681.                 } else {
  3682.                     if ((_arg1[_local2] is Object)){
  3683.                         encodeCharactersThatLameExternalInterfaceChokesOn(_arg1[_local2]);
  3684.                     };
  3685.                 };
  3686.             };
  3687.         }
  3688.  
  3689.         private function initLocalConnection():void{
  3690.             localConnection.client = {
  3691.                 updateVariable:sessionObject.updateVariable,
  3692.                 onReset:socket.onReset
  3693.             };
  3694.             localConnection.connect(ZConfig.tabIdentifier);
  3695.         }
  3696.         private function addExternalInterfaceCallbacks():void{
  3697.             if (!ExternalInterface.available){
  3698.                 ZConfig.traceTime("External interface is not available for this container.");
  3699.                 return;
  3700.             };
  3701.             try {
  3702.                 ZConfig.traceTime("Enabling external interfaces...");
  3703.                 ExternalInterface.addCallback("jsSend", socket.jsSend);
  3704.                 ExternalInterface.addCallback("jsAlert", SoundAlert.play);
  3705.                 ExternalInterface.addCallback("disconnect", onJSWindowUnload);
  3706.                 ExternalInterface.addCallback("connect", socket.connect);
  3707.                 ExternalInterface.addCallback("reset", socket.reset);
  3708.             } catch(error:Error) {
  3709.                 ZConfig.traceTime((error.message + "\n"));
  3710.             };
  3711.         }
  3712.         private function onJSWindowUnload(_arg1:Object=null):void{
  3713.             socket.disconnect();
  3714.             sessionObject.disconnect(_arg1);
  3715.         }
  3716.         private function dispatchToJS(_arg1:Object):void{
  3717.             encodeCharactersThatLameExternalInterfaceChokesOn(_arg1);
  3718.             ExternalInterface.call("__$$__meshim__Socket.dispatch", _arg1);
  3719.         }
  3720.  
  3721.     }
  3722. }//package
  3723. package {
  3724.     import flash.events.*;
  3725.     import zopim.events.*;
  3726.     import zopim.*;
  3727.     import flash.utils.*;
  3728.     import com.adobe.serialization.json.*;
  3729.  
  3730.     public class ZClientSocket extends ZSocket {
  3731.  
  3732.         private static const JS_VERSION:String = "0.4.0";
  3733.         private static const SWF_VERSION:String = "2371";
  3734.         private static const REDIRECT:String = "redirect";
  3735.  
  3736.         private const suppressInitFlags:Object;
  3737.  
  3738.         private var passThroughCallback:Function;
  3739.         private var sessionObject:SessionObject;
  3740.         private var initialized:Boolean = false;
  3741.         private var idleDisconnected:Boolean = false;
  3742.         private var idleDisconnectedBuffer:Array;
  3743.         private var isResetting:Boolean = false;
  3744.         private var registerCache:Object;
  3745.  
  3746.         public function ZClientSocket(_arg1:Function=null, _arg2:SessionObject=null){
  3747.             idleDisconnectedBuffer = [];
  3748.             suppressInitFlags = {
  3749.                 banned:true,
  3750.                 nossl:true,
  3751.                 disconnect:true
  3752.             };
  3753.             this.sessionObject = _arg2;
  3754.             this.passThroughCallback = _arg1;
  3755.             super();
  3756.         }
  3757.         public function initSocket():void{
  3758.             if (initialized){
  3759.                 return;
  3760.             };
  3761.             initialized = true;
  3762.             initiateSession();
  3763.             jsonMap.addMapping("config", ZConfiguration);
  3764.             jsonMap.addMapping("idle_disconnect", ZIdleDisconnect);
  3765.             jsonMap.addMapping("banned", ZBanned);
  3766.             jsonMap.addMapping("reset", ZReset);
  3767.             addEventListener(ZConfiguration.TYPE, function (_arg1:ZConfiguration):void{
  3768.                 ZConfig.update(_arg1.json);
  3769.             });
  3770.             addEventListener(ZIdleDisconnect.TYPE, onIdleDisconnect);
  3771.             addEventListener(ZBanned.TYPE, function (_arg1:ZBanned):void{
  3772.                 disconnect();
  3773.             });
  3774.             addEventListener(ZReset.TYPE, onReset);
  3775.             if (!suppressInit){
  3776.                 dispatchObject({__type:"flashready"});
  3777.             };
  3778.         }
  3779.         private function onIdleDisconnect(_arg1:ZIdleDisconnect=null):void{
  3780.             idleDisconnected = true;
  3781.             idleDisconnectedBuffer.splice(0, idleDisconnectedBuffer.length);
  3782.             disconnect();
  3783.         }
  3784.         override public function connect(_arg1:String="", _arg2:uint=0):void{
  3785.             this.host = ((((sessionObject.cachedData.host) || (_arg1))) || (this.host));
  3786.             this.port = ((((sessionObject.cachedData.port) || (_arg2))) || (this.port));
  3787.             if (getCachedConnectionMode() == POLLING_CONNECTION){
  3788.                 httpFallback();
  3789.             };
  3790.             super.connect();
  3791.         }
  3792.         public function reset():void{
  3793.             isResetting = true;
  3794.             if (connected){
  3795.                 send("clear_all");
  3796.             };
  3797.         }
  3798.         public function onReset(_arg1:ZReset=null):void{
  3799.             isResetting = false;
  3800.             sessionObject.clear();
  3801.             ZConfig.clear();
  3802.             disconnect();
  3803.             if ((_arg1 is ZReset)){
  3804.                 ZConfig.saveValue("machineID", _arg1.machineID);
  3805.                 httpSocket.evt = _arg1.evt;
  3806.                 sid = _arg1.sid;
  3807.             };
  3808.             passThrough({__type:"reset"});
  3809.             connect();
  3810.         }
  3811.         private function saveValue(_arg1:String, _arg2):void{
  3812.             sessionObject.saveValue(_arg1, _arg2);
  3813.         }
  3814.         private function getValue(_arg1:String){
  3815.             return (sessionObject.cachedData[_arg1]);
  3816.         }
  3817.         private function get suppressInit():Boolean{
  3818.             var _local1:String;
  3819.             for (_local1 in suppressInitFlags) {
  3820.                 if (getValue(_local1)){
  3821.                     return (true);
  3822.                 };
  3823.             };
  3824.             return (false);
  3825.         }
  3826.         private function set suppressInit(_arg1:Boolean):void{
  3827.             var _local2:String;
  3828.             if (!_arg1){
  3829.                 for (_local2 in suppressInitFlags) {
  3830.                     saveValue(_local2, false);
  3831.                 };
  3832.             };
  3833.         }
  3834.         private function initiateSession():void{
  3835.             if (sid){
  3836.                 connect();
  3837.                 return;
  3838.             };
  3839.             if (!ZConfig.accountKey){
  3840.                 ZConfig.traceTime("no accountKey");
  3841.                 return;
  3842.             };
  3843.             var obj:* = {
  3844.                 mID:((ZConfig.machineID) || ("")),
  3845.                 url:((ZConfig.pageUrl) || ("")),
  3846.                 ua:((ZConfig.ua) || ("")),
  3847.                 ak:((ZConfig.accountKey) || ("")),
  3848.                 sk:((ZConfig.secretKey) || ("")),
  3849.                 mID:((ZConfig.machineID) || ("")),
  3850.                 ua:((ZConfig.ua) || ("")),
  3851.                 title:((ZConfig.pageTitle) || ("")),
  3852.                 url:((ZConfig.pageUrl) || ("")),
  3853.                 ref:((ZConfig.referrer) || ("")),
  3854.                 tabId:((ZConfig.tabIdentifier) || ("")),
  3855.                 jsVer:((JS_VERSION) || ("")),
  3856.                 swfVer:((SWF_VERSION) || ("")),
  3857.                 accountKey:((ZConfig.accountKey) || (""))
  3858.             };
  3859.             httpSocket.sendRegister(obj, onRegister, function onError (_arg1:Event):void{
  3860.                 onErrorConnection();
  3861.             });
  3862.         }
  3863.         override protected function httpFallback():void{
  3864.             if (connectionMode == NO_CONNECTION){
  3865.                 super.httpFallback();
  3866.                 if (connectionMode == POLLING_CONNECTION){
  3867.                     reattach();
  3868.                 };
  3869.             };
  3870.         }
  3871.         override protected function get connectionMode():uint{
  3872.             return (_connectionMode);
  3873.         }
  3874.         override protected function set connectionMode(_arg1:uint):void{
  3875.             ZConfig.traceTime(("_connectionMode set >> " + (((_arg1 == 1)) ? "SOCKET_CONNECTION" : (((_arg1 == 2)) ? "POLLING_CONNECTION" : "NONE"))));
  3876.             _connectionMode = _arg1;
  3877.             if (sessionObject){
  3878.                 sessionObject.saveValues({_connectionMode:_arg1});
  3879.             };
  3880.         }
  3881.         protected function getCachedConnectionMode():uint{
  3882.             var _local1:uint;
  3883.             if (sessionObject){
  3884.                 _local1 = sessionObject.cachedData["_connectionMode"];
  3885.             };
  3886.             if ((_local1 is uint)){
  3887.                 return (_local1);
  3888.             };
  3889.             return (0);
  3890.         }
  3891.         public function jsSend(_arg1:Object):void{
  3892.             if (((((((idleDisconnected) && (_arg1))) && (_arg1.__type))) && ((_arg1.__type == "client.active")))){
  3893.                 if (!idleDisconnectedBuffer.length){
  3894.                     initiateSession();
  3895.                 };
  3896.                 idleDisconnectedBuffer.push(_arg1);
  3897.                 return;
  3898.             };
  3899.             var _local2:String = JSON.encode(_arg1);
  3900.             send(_arg1["__type"], _arg1);
  3901.         }
  3902.         override public function dispatchObject(_arg1:Object):void{
  3903.             var _local3:Function;
  3904.             var _local4:ZEvent;
  3905.             if (!_arg1){
  3906.                 return;
  3907.             };
  3908.             var _local2:String = _arg1["__type"];
  3909.             if (_local2 == "response"){
  3910.                 _local3 = callbacks[_arg1["__messageID"]];
  3911.                 if ((_local3 is Function)){
  3912.                     _local3(_arg1);
  3913.                 } else {
  3914.                     passThrough(_arg1);
  3915.                 };
  3916.             } else {
  3917.                 _local4 = jsonMap.jsonToEvent(_arg1);
  3918.                 dispatchEvent(_local4);
  3919.                 passThrough(_arg1);
  3920.             };
  3921.         }
  3922.         private function passThrough(_arg1:Object):void{
  3923.             if ((passThroughCallback is Function)){
  3924.                 passThroughCallback(_arg1);
  3925.             };
  3926.         }
  3927.         override protected function onConnect(_arg1:Event):void{
  3928.             super.onConnect(_arg1);
  3929.             reattach();
  3930.         }
  3931.         private function onRegister(_arg1:Object):void{
  3932.             var _local2:Object;
  3933.             if (_arg1.__status == "ok"){
  3934.                 registerCache = _arg1;
  3935.                 ZConfig.update(_arg1);
  3936.                 _nick = _arg1.nick;
  3937.                 sid = _arg1.sid;
  3938.                 startPoll(_arg1);
  3939.                 if (!isResetting){
  3940.                     if (suppressInit){
  3941.                         suppressInit = false;
  3942.                         dispatchObject({__type:"flashready"});
  3943.                     };
  3944.                     _arg1["__type"] = "init";
  3945.                     dispatchObject(_arg1);
  3946.                     startKeepAlive();
  3947.                     reconnectDelay = DEFAULT_RECONNECT_DELAY;
  3948.                     if (idleDisconnected){
  3949.                         idleDisconnected = false;
  3950.                         for each (_local2 in idleDisconnectedBuffer) {
  3951.                             jsSend(_local2);
  3952.                         };
  3953.                         idleDisconnectedBuffer.splice(0, idleDisconnectedBuffer.length);
  3954.                     };
  3955.                 };
  3956.                 connect(_arg1.host);
  3957.             } else {
  3958.                 if (suppressInitFlags[_arg1.__status]){
  3959.                     saveValue(_arg1.__status, true);
  3960.                     dispatchObject({__type:_arg1.__status});
  3961.                 } else {
  3962.                     dispatchConnectionError(_arg1);
  3963.                 };
  3964.             };
  3965.         }
  3966.         override protected function onErrorConnection(_arg1:ZErrorConnection=null):void{
  3967.             clearTimeout(connectTimeoutId);
  3968.             ZConfig.traceTime((("ZSocket reconnecting in " + (reconnectDelay / 1000)) + "secs."));
  3969.             connectTimeoutId = setTimeout(initiateSession, reconnectDelay);
  3970.             reconnectDelay = (reconnectDelay + (((reconnectDelay < MAX_RECONNECT_DELAY)) ? reconnectDelay : 0));
  3971.         }
  3972.         override protected function onReattach(_arg1:Object):void{
  3973.             if (_arg1.__status == "ok"){
  3974.                 dispatchObject({
  3975.                     __type:"connected",
  3976.                     displayName:_arg1.name,
  3977.                     nick:_arg1.nick
  3978.                 });
  3979.                 passThrough({__type:"reattached"});
  3980.                 registerCache.__type = "init";
  3981.                 passThrough(registerCache);
  3982.                 startPoll(_arg1);
  3983.                 startKeepAlive();
  3984.                 reconnectDelay = DEFAULT_RECONNECT_DELAY;
  3985.                 if (isResetting){
  3986.                     reset();
  3987.                 };
  3988.             } else {
  3989.                 if (_arg1.__status == "failed"){
  3990.                     sid = null;
  3991.                     initiateSession();
  3992.                 } else {
  3993.                     dispatchConnectionError(_arg1);
  3994.                 };
  3995.             };
  3996.         }
  3997.  
  3998.     }
  3999. }//package
  4000. package com.adobe.crypto {
  4001.     import flash.utils.*;
  4002.     import mx.utils.*;
  4003.     import com.adobe.utils.*;
  4004.  
  4005.     public class SHA1 {
  4006.  
  4007.         public static function hash(_arg1:String):String{
  4008.             var _local2:Array = createBlocksFromString(_arg1);
  4009.             var _local3:ByteArray = hashBlocks(_local2);
  4010.             return (((((IntUtil.toHex(_local3.readInt(), true) + IntUtil.toHex(_local3.readInt(), true)) + IntUtil.toHex(_local3.readInt(), true)) + IntUtil.toHex(_local3.readInt(), true)) + IntUtil.toHex(_local3.readInt(), true)));
  4011.         }
  4012.         public static function hashBytes(_arg1:ByteArray):String{
  4013.             var _local2:Array = SHA1.createBlocksFromByteArray(_arg1);
  4014.             var _local3:ByteArray = hashBlocks(_local2);
  4015.             return (((((IntUtil.toHex(_local3.readInt(), true) + IntUtil.toHex(_local3.readInt(), true)) + IntUtil.toHex(_local3.readInt(), true)) + IntUtil.toHex(_local3.readInt(), true)) + IntUtil.toHex(_local3.readInt(), true)));
  4016.         }
  4017.         public static function hashToBase64(_arg1:String):String{
  4018.             var _local7:uint;
  4019.             var _local2:Array = SHA1.createBlocksFromString(_arg1);
  4020.             var _local3:ByteArray = hashBlocks(_local2);
  4021.             var _local4 = "";
  4022.             _local3.position = 0;
  4023.             var _local5:int;
  4024.             while (_local5 < _local3.length) {
  4025.                 _local7 = _local3.readUnsignedByte();
  4026.                 _local4 = (_local4 + String.fromCharCode(_local7));
  4027.                 _local5++;
  4028.             };
  4029.             var _local6:Base64Encoder = new Base64Encoder();
  4030.             _local6.encode(_local4);
  4031.             return (_local6.flush());
  4032.         }
  4033.         private static function hashBlocks(_arg1:Array):ByteArray{
  4034.             var _local11:int;
  4035.             var _local12:int;
  4036.             var _local13:int;
  4037.             var _local14:int;
  4038.             var _local15:int;
  4039.             var _local16:int;
  4040.             var _local17:int;
  4041.             var _local2 = 1732584193;
  4042.             var _local3:int = 4023233417;
  4043.             var _local4:int = 2562383102;
  4044.             var _local5 = 271733878;
  4045.             var _local6:int = 3285377520;
  4046.             var _local7:int = _arg1.length;
  4047.             var _local8:Array = new Array(80);
  4048.             var _local9:int;
  4049.             while (_local9 < _local7) {
  4050.                 _local11 = _local2;
  4051.                 _local12 = _local3;
  4052.                 _local13 = _local4;
  4053.                 _local14 = _local5;
  4054.                 _local15 = _local6;
  4055.                 _local16 = 0;
  4056.                 while (_local16 < 80) {
  4057.                     if (_local16 < 16){
  4058.                         _local8[_local16] = _arg1[(_local9 + _local16)];
  4059.                     } else {
  4060.                         _local8[_local16] = IntUtil.rol((((_local8[(_local16 - 3)] ^ _local8[(_local16 - 8)]) ^ _local8[(_local16 - 14)]) ^ _local8[(_local16 - 16)]), 1);
  4061.                     };
  4062.                     _local17 = ((((IntUtil.rol(_local11, 5) + f(_local16, _local12, _local13, _local14)) + _local15) + int(_local8[_local16])) + k(_local16));
  4063.                     _local15 = _local14;
  4064.                     _local14 = _local13;
  4065.                     _local13 = IntUtil.rol(_local12, 30);
  4066.                     _local12 = _local11;
  4067.                     _local11 = _local17;
  4068.                     _local16++;
  4069.                 };
  4070.                 _local2 = (_local2 + _local11);
  4071.                 _local3 = (_local3 + _local12);
  4072.                 _local4 = (_local4 + _local13);
  4073.                 _local5 = (_local5 + _local14);
  4074.                 _local6 = (_local6 + _local15);
  4075.                 _local9 = (_local9 + 16);
  4076.             };
  4077.             var _local10:ByteArray = new ByteArray();
  4078.             _local10.writeInt(_local2);
  4079.             _local10.writeInt(_local3);
  4080.             _local10.writeInt(_local4);
  4081.             _local10.writeInt(_local5);
  4082.             _local10.writeInt(_local6);
  4083.             _local10.position = 0;
  4084.             return (_local10);
  4085.         }
  4086.         private static function f(_arg1:int, _arg2:int, _arg3:int, _arg4:int):int{
  4087.             if (_arg1 < 20){
  4088.                 return (((_arg2 & _arg3) | (~(_arg2) & _arg4)));
  4089.             };
  4090.             if (_arg1 < 40){
  4091.                 return (((_arg2 ^ _arg3) ^ _arg4));
  4092.             };
  4093.             if (_arg1 < 60){
  4094.                 return ((((_arg2 & _arg3) | (_arg2 & _arg4)) | (_arg3 & _arg4)));
  4095.             };
  4096.             return (((_arg2 ^ _arg3) ^ _arg4));
  4097.         }
  4098.         private static function k(_arg1:int):int{
  4099.             if (_arg1 < 20){
  4100.                 return (1518500249);
  4101.             };
  4102.             if (_arg1 < 40){
  4103.                 return (1859775393);
  4104.             };
  4105.             if (_arg1 < 60){
  4106.                 return (2400959708);
  4107.             };
  4108.             return (3395469782);
  4109.         }
  4110.         private static function createBlocksFromByteArray(_arg1:ByteArray):Array{
  4111.             var _local2:int = _arg1.position;
  4112.             _arg1.position = 0;
  4113.             var _local3:Array = new Array();
  4114.             var _local4:int = (_arg1.length * 8);
  4115.             var _local5 = 0xFF;
  4116.             var _local6:int;
  4117.             while (_local6 < _local4) {
  4118.                 _local3[(_local6 >> 5)] = (_local3[(_local6 >> 5)] | ((_arg1.readByte() & _local5) << (24 - (_local6 % 32))));
  4119.                 _local6 = (_local6 + 8);
  4120.             };
  4121.             _local3[(_local4 >> 5)] = (_local3[(_local4 >> 5)] | (128 << (24 - (_local4 % 32))));
  4122.             _local3[((((_local4 + 64) >> 9) << 4) + 15)] = _local4;
  4123.             _arg1.position = _local2;
  4124.             return (_local3);
  4125.         }
  4126.         private static function createBlocksFromString(_arg1:String):Array{
  4127.             var _local2:Array = new Array();
  4128.             var _local3:int = (_arg1.length * 8);
  4129.             var _local4 = 0xFF;
  4130.             var _local5:int;
  4131.             while (_local5 < _local3) {
  4132.                 _local2[(_local5 >> 5)] = (_local2[(_local5 >> 5)] | ((_arg1.charCodeAt((_local5 / 8)) & _local4) << (24 - (_local5 % 32))));
  4133.                 _local5 = (_local5 + 8);
  4134.             };
  4135.             _local2[(_local3 >> 5)] = (_local2[(_local3 >> 5)] | (128 << (24 - (_local3 % 32))));
  4136.             _local2[((((_local3 + 64) >> 9) << 4) + 15)] = _local3;
  4137.             return (_local2);
  4138.         }
  4139.  
  4140.     }
  4141. }//package com.adobe.crypto
  4142. package com.adobe.serialization.json {
  4143.  
  4144.     public class JSONToken {
  4145.  
  4146.         private var _type:int;
  4147.         private var _value:Object;
  4148.  
  4149.         public function JSONToken(_arg1:int=-1, _arg2:Object=null){
  4150.             _type = _arg1;
  4151.             _value = _arg2;
  4152.         }
  4153.         public function get type():int{
  4154.             return (_type);
  4155.         }
  4156.         public function set type(_arg1:int):void{
  4157.             _type = _arg1;
  4158.         }
  4159.         public function get value():Object{
  4160.             return (_value);
  4161.         }
  4162.         public function set value(_arg1:Object):void{
  4163.             _value = _arg1;
  4164.         }
  4165.  
  4166.     }
  4167. }//package com.adobe.serialization.json
  4168. package com.adobe.serialization.json {
  4169.     import flash.utils.*;
  4170.  
  4171.     public class JSONEncoder {
  4172.  
  4173.         private var jsonString:String;
  4174.  
  4175.         public function JSONEncoder(_arg1){
  4176.             jsonString = convertToString(_arg1);
  4177.         }
  4178.         public function getString():String{
  4179.             return (jsonString);
  4180.         }
  4181.         private function convertToString(_arg1):String{
  4182.             if ((_arg1 is String)){
  4183.                 return (escapeString((_arg1 as String)));
  4184.             };
  4185.             if ((_arg1 is Number)){
  4186.                 return (((isFinite((_arg1 as Number))) ? _arg1.toString() : "null"));
  4187.             };
  4188.             if ((_arg1 is Boolean)){
  4189.                 return (((_arg1) ? "true" : "false"));
  4190.             };
  4191.             if ((_arg1 is Array)){
  4192.                 return (arrayToString((_arg1 as Array)));
  4193.             };
  4194.             if ((((_arg1 is Object)) && (!((_arg1 == null))))){
  4195.                 return (objectToString(_arg1));
  4196.             };
  4197.             return ("null");
  4198.         }
  4199.         private function escapeString(_arg1:String):String{
  4200.             var _local3:String;
  4201.             var _local6:String;
  4202.             var _local7:String;
  4203.             var _local2 = "";
  4204.             var _local4:Number = _arg1.length;
  4205.             var _local5:int;
  4206.             while (_local5 < _local4) {
  4207.                 _local3 = _arg1.charAt(_local5);
  4208.                 switch (_local3){
  4209.                     case "\"":
  4210.                         _local2 = (_local2 + "\\\"");
  4211.                         break;
  4212.                     case "\\":
  4213.                         _local2 = (_local2 + "\\\\");
  4214.                         break;
  4215.                     case "\b":
  4216.                         _local2 = (_local2 + "\\b");
  4217.                         break;
  4218.                     case "\f":
  4219.                         _local2 = (_local2 + "\\f");
  4220.                         break;
  4221.                     case "\n":
  4222.                         _local2 = (_local2 + "\\n");
  4223.                         break;
  4224.                     case "\r":
  4225.                         _local2 = (_local2 + "\\r");
  4226.                         break;
  4227.                     case "\t":
  4228.                         _local2 = (_local2 + "\\t");
  4229.                         break;
  4230.                     default:
  4231.                         if ((((_local3 < " ")) || ((_local3.charCodeAt(0) > 127)))){
  4232.                             _local6 = _local3.charCodeAt(0).toString(16);
  4233.                             switch (_local6.length){
  4234.                                 case 1:
  4235.                                     _local7 = "000";
  4236.                                     break;
  4237.                                 case 2:
  4238.                                     _local7 = "00";
  4239.                                     break;
  4240.                                 case 3:
  4241.                                     _local7 = "0";
  4242.                                     break;
  4243.                                 default:
  4244.                                     _local7 = "";
  4245.                             };
  4246.                             _local2 = (_local2 + (("\\u" + _local7) + _local6));
  4247.                         } else {
  4248.                             _local2 = (_local2 + _local3);
  4249.                         };
  4250.                 };
  4251.                 _local5++;
  4252.             };
  4253.             return ((("\"" + _local2) + "\""));
  4254.         }
  4255.         private function arrayToString(_arg1:Array):String{
  4256.             var _local2 = "";
  4257.             var _local3:int;
  4258.             while (_local3 < _arg1.length) {
  4259.                 if (_local2.length > 0){
  4260.                     _local2 = (_local2 + ",");
  4261.                 };
  4262.                 _local2 = (_local2 + convertToString(_arg1[_local3]));
  4263.                 _local3++;
  4264.             };
  4265.             return ((("[" + _local2) + "]"));
  4266.         }
  4267.         private function objectToString(_arg1:Object):String{
  4268.             var value:* = null;
  4269.             var key:* = null;
  4270.             var v:* = null;
  4271.             var o:* = _arg1;
  4272.             var s:* = "";
  4273.             var classInfo:* = describeType(o);
  4274.             if (classInfo.@name.toString() == "Object"){
  4275.                 for (key in o) {
  4276.                     value = o[key];
  4277.                     if ((value is Function)){
  4278.                     } else {
  4279.                         if (s.length > 0){
  4280.                             s = (s + ",");
  4281.                         };
  4282.                         s = (s + ((escapeString(key) + ":") + convertToString(value)));
  4283.                     };
  4284.                 };
  4285.             } else {
  4286.                 for each (v in classInfo..*.(((name() == "variable")) || ((name() == "accessor")))) {
  4287.                     if (s.length > 0){
  4288.                         s = (s + ",");
  4289.                     };
  4290.                     s = (s + ((escapeString(v.@name.toString()) + ":") + convertToString(o[v.@name])));
  4291.                 };
  4292.             };
  4293.             return ((("{" + s) + "}"));
  4294.         }
  4295.  
  4296.     }
  4297. }//package com.adobe.serialization.json
  4298. package com.adobe.serialization.json {
  4299.  
  4300.     public class JSONParseError extends Error {
  4301.  
  4302.         private var _location:int;
  4303.         private var _text:String;
  4304.  
  4305.         public function JSONParseError(_arg1:String="", _arg2:int=0, _arg3:String=""){
  4306.             super(_arg1);
  4307.             _location = _arg2;
  4308.             _text = _arg3;
  4309.         }
  4310.         public function get location():int{
  4311.             return (_location);
  4312.         }
  4313.         public function get text():String{
  4314.             return (_text);
  4315.         }
  4316.  
  4317.     }
  4318. }//package com.adobe.serialization.json
  4319. package com.adobe.serialization.json {
  4320.  
  4321.     public class JSONTokenizer {
  4322.  
  4323.         private var obj:Object;
  4324.         private var jsonString:String;
  4325.         private var loc:int;
  4326.         private var ch:String;
  4327.  
  4328.         public function JSONTokenizer(_arg1:String){
  4329.             jsonString = _arg1;
  4330.             loc = 0;
  4331.             nextChar();
  4332.         }
  4333.         public function getNextToken():JSONToken{
  4334.             var _local2:String;
  4335.             var _local3:String;
  4336.             var _local4:String;
  4337.             var _local1:JSONToken = new JSONToken();
  4338.             skipIgnored();
  4339.             switch (ch){
  4340.                 case "{":
  4341.                     _local1.type = JSONTokenType.LEFT_BRACE;
  4342.                     _local1.value = "{";
  4343.                     nextChar();
  4344.                     break;
  4345.                 case "}":
  4346.                     _local1.type = JSONTokenType.RIGHT_BRACE;
  4347.                     _local1.value = "}";
  4348.                     nextChar();
  4349.                     break;
  4350.                 case "[":
  4351.                     _local1.type = JSONTokenType.LEFT_BRACKET;
  4352.                     _local1.value = "[";
  4353.                     nextChar();
  4354.                     break;
  4355.                 case "]":
  4356.                     _local1.type = JSONTokenType.RIGHT_BRACKET;
  4357.                     _local1.value = "]";
  4358.                     nextChar();
  4359.                     break;
  4360.                 case ",":
  4361.                     _local1.type = JSONTokenType.COMMA;
  4362.                     _local1.value = ",";
  4363.                     nextChar();
  4364.                     break;
  4365.                 case ":":
  4366.                     _local1.type = JSONTokenType.COLON;
  4367.                     _local1.value = ":";
  4368.                     nextChar();
  4369.                     break;
  4370.                 case "t":
  4371.                     _local2 = ((("t" + nextChar()) + nextChar()) + nextChar());
  4372.                     if (_local2 == "true"){
  4373.                         _local1.type = JSONTokenType.TRUE;
  4374.                         _local1.value = true;
  4375.                         nextChar();
  4376.                     } else {
  4377.                         parseError(("Expecting 'true' but found " + _local2));
  4378.                     };
  4379.                     break;
  4380.                 case "f":
  4381.                     _local3 = (((("f" + nextChar()) + nextChar()) + nextChar()) + nextChar());
  4382.                     if (_local3 == "false"){
  4383.                         _local1.type = JSONTokenType.FALSE;
  4384.                         _local1.value = false;
  4385.                         nextChar();
  4386.                     } else {
  4387.                         parseError(("Expecting 'false' but found " + _local3));
  4388.                     };
  4389.                     break;
  4390.                 case "n":
  4391.                     _local4 = ((("n" + nextChar()) + nextChar()) + nextChar());
  4392.                     if (_local4 == "null"){
  4393.                         _local1.type = JSONTokenType.NULL;
  4394.                         _local1.value = null;
  4395.                         nextChar();
  4396.                     } else {
  4397.                         parseError(("Expecting 'null' but found " + _local4));
  4398.                     };
  4399.                     break;
  4400.                 case "\"":
  4401.                     _local1 = readString();
  4402.                     break;
  4403.                 default:
  4404.                     if (((isDigit(ch)) || ((ch == "-")))){
  4405.                         _local1 = readNumber();
  4406.                     } else {
  4407.                         if (ch == ""){
  4408.                             return (null);
  4409.                         };
  4410.                         parseError((("Unexpected " + ch) + " encountered"));
  4411.                     };
  4412.             };
  4413.             return (_local1);
  4414.         }
  4415.         private function readString():JSONToken{
  4416.             var _local3:String;
  4417.             var _local4:int;
  4418.             var _local1:JSONToken = new JSONToken();
  4419.             _local1.type = JSONTokenType.STRING;
  4420.             var _local2 = "";
  4421.             nextChar();
  4422.             while (((!((ch == "\""))) && (!((ch == ""))))) {
  4423.                 if (ch == "\\"){
  4424.                     nextChar();
  4425.                     switch (ch){
  4426.                         case "\"":
  4427.                             _local2 = (_local2 + "\"");
  4428.                             break;
  4429.                         case "/":
  4430.                             _local2 = (_local2 + "/");
  4431.                             break;
  4432.                         case "\\":
  4433.                             _local2 = (_local2 + "\\");
  4434.                             break;
  4435.                         case "b":
  4436.                             _local2 = (_local2 + "\b");
  4437.                             break;
  4438.                         case "f":
  4439.                             _local2 = (_local2 + "\f");
  4440.                             break;
  4441.                         case "n":
  4442.                             _local2 = (_local2 + "\n");
  4443.                             break;
  4444.                         case "r":
  4445.                             _local2 = (_local2 + "\r");
  4446.                             break;
  4447.                         case "t":
  4448.                             _local2 = (_local2 + "\t");
  4449.                             break;
  4450.                         case "u":
  4451.                             _local3 = "";
  4452.                             _local4 = 0;
  4453.                             while (_local4 < 4) {
  4454.                                 if (!isHexDigit(nextChar())){
  4455.                                     parseError((" Excepted a hex digit, but found: " + ch));
  4456.                                 };
  4457.                                 _local3 = (_local3 + ch);
  4458.                                 _local4++;
  4459.                             };
  4460.                             _local2 = (_local2 + String.fromCharCode(parseInt(_local3, 16)));
  4461.                             break;
  4462.                         default:
  4463.                             _local2 = (_local2 + ("\\" + ch));
  4464.                     };
  4465.                 } else {
  4466.                     _local2 = (_local2 + ch);
  4467.                 };
  4468.                 nextChar();
  4469.             };
  4470.             if (ch == ""){
  4471.                 parseError("Unterminated string literal");
  4472.             };
  4473.             nextChar();
  4474.             _local1.value = _local2;
  4475.             return (_local1);
  4476.         }
  4477.         private function readNumber():JSONToken{
  4478.             var _local1:JSONToken = new JSONToken();
  4479.             _local1.type = JSONTokenType.NUMBER;
  4480.             var _local2 = "";
  4481.             if (ch == "-"){
  4482.                 _local2 = (_local2 + "-");
  4483.                 nextChar();
  4484.             };
  4485.             if (!isDigit(ch)){
  4486.                 parseError("Expecting a digit");
  4487.             };
  4488.             if (ch == "0"){
  4489.                 _local2 = (_local2 + ch);
  4490.                 nextChar();
  4491.                 if (isDigit(ch)){
  4492.                     parseError("A digit cannot immediately follow 0");
  4493.                 };
  4494.             } else {
  4495.                 while (isDigit(ch)) {
  4496.                     _local2 = (_local2 + ch);
  4497.                     nextChar();
  4498.                 };
  4499.             };
  4500.             if (ch == "."){
  4501.                 _local2 = (_local2 + ".");
  4502.                 nextChar();
  4503.                 if (!isDigit(ch)){
  4504.                     parseError("Expecting a digit");
  4505.                 };
  4506.                 while (isDigit(ch)) {
  4507.                     _local2 = (_local2 + ch);
  4508.                     nextChar();
  4509.                 };
  4510.             };
  4511.             if ((((ch == "e")) || ((ch == "E")))){
  4512.                 _local2 = (_local2 + "e");
  4513.                 nextChar();
  4514.                 if ((((ch == "+")) || ((ch == "-")))){
  4515.                     _local2 = (_local2 + ch);
  4516.                     nextChar();
  4517.                 };
  4518.                 if (!isDigit(ch)){
  4519.                     parseError("Scientific notation number needs exponent value");
  4520.                 };
  4521.                 while (isDigit(ch)) {
  4522.                     _local2 = (_local2 + ch);
  4523.                     nextChar();
  4524.                 };
  4525.             };
  4526.             var _local3:Number = Number(_local2);
  4527.             if (((isFinite(_local3)) && (!(isNaN(_local3))))){
  4528.                 _local1.value = _local3;
  4529.                 return (_local1);
  4530.             };
  4531.             parseError((("Number " + _local3) + " is not valid!"));
  4532.             return (null);
  4533.         }
  4534.         private function nextChar():String{
  4535.             return ((ch = jsonString.charAt(loc++)));
  4536.         }
  4537.         private function skipIgnored():void{
  4538.             skipWhite();
  4539.             skipComments();
  4540.             skipWhite();
  4541.         }
  4542.         private function skipComments():void{
  4543.             if (ch == "/"){
  4544.                 nextChar();
  4545.                 switch (ch){
  4546.                     case "/":
  4547.                         do  {
  4548.                             nextChar();
  4549.                         } while (((!((ch == "\n"))) && (!((ch == "")))));
  4550.                         nextChar();
  4551.                         break;
  4552.                     case "*":
  4553.                         nextChar();
  4554.                         while (true) {
  4555.                             if (ch == "*"){
  4556.                                 nextChar();
  4557.                                 if (ch == "/"){
  4558.                                     nextChar();
  4559.                                     break;
  4560.                                 };
  4561.                             } else {
  4562.                                 nextChar();
  4563.                             };
  4564.                             if (ch == ""){
  4565.                                 parseError("Multi-line comment not closed");
  4566.                             };
  4567.                         };
  4568.                         break;
  4569.                     default:
  4570.                         parseError((("Unexpected " + ch) + " encountered (expecting '/' or '*' )"));
  4571.                 };
  4572.             };
  4573.         }
  4574.         private function skipWhite():void{
  4575.             while (isWhiteSpace(ch)) {
  4576.                 nextChar();
  4577.             };
  4578.         }
  4579.         private function isWhiteSpace(_arg1:String):Boolean{
  4580.             return ((((((_arg1 == " ")) || ((_arg1 == "\t")))) || ((_arg1 == "\n"))));
  4581.         }
  4582.         private function isDigit(_arg1:String):Boolean{
  4583.             return ((((_arg1 >= "0")) && ((_arg1 <= "9"))));
  4584.         }
  4585.         private function isHexDigit(_arg1:String):Boolean{
  4586.             var _local2:String = _arg1.toUpperCase();
  4587.             return (((isDigit(_arg1)) || ((((_local2 >= "A")) && ((_local2 <= "F"))))));
  4588.         }
  4589.         public function parseError(_arg1:String):void{
  4590.             throw (new JSONParseError(_arg1, loc, jsonString));
  4591.         }
  4592.  
  4593.     }
  4594. }//package com.adobe.serialization.json
  4595. package com.adobe.serialization.json {
  4596.  
  4597.     public class JSONTokenType {
  4598.  
  4599.         public static const UNKNOWN:int = -1;
  4600.         public static const COMMA:int = 0;
  4601.         public static const LEFT_BRACE:int = 1;
  4602.         public static const RIGHT_BRACE:int = 2;
  4603.         public static const LEFT_BRACKET:int = 3;
  4604.         public static const RIGHT_BRACKET:int = 4;
  4605.         public static const COLON:int = 6;
  4606.         public static const TRUE:int = 7;
  4607.         public static const FALSE:int = 8;
  4608.         public static const NULL:int = 9;
  4609.         public static const STRING:int = 10;
  4610.         public static const NUMBER:int = 11;
  4611.  
  4612.     }
  4613. }//package com.adobe.serialization.json
  4614. package com.adobe.serialization.json {
  4615.  
  4616.     public class JSONDecoder {
  4617.  
  4618.         private var value;
  4619.         private var tokenizer:JSONTokenizer;
  4620.         private var token:JSONToken;
  4621.  
  4622.         public function JSONDecoder(_arg1:String){
  4623.             tokenizer = new JSONTokenizer(_arg1);
  4624.             nextToken();
  4625.             value = parseValue();
  4626.         }
  4627.         public function getValue(){
  4628.             return (value);
  4629.         }
  4630.         private function nextToken():JSONToken{
  4631.             return ((token = tokenizer.getNextToken()));
  4632.         }
  4633.         private function parseArray():Array{
  4634.             var _local1:Array = new Array();
  4635.             nextToken();
  4636.             if (token.type == JSONTokenType.RIGHT_BRACKET){
  4637.                 return (_local1);
  4638.             };
  4639.             _local1.push(parseValue());
  4640.             nextToken();
  4641.             if (token.type == JSONTokenType.RIGHT_BRACKET){
  4642.                 return (_local1);
  4643.             };
  4644.             if (token.type == JSONTokenType.COMMA){
  4645.                 nextToken();
  4646.             } else {
  4647.                 tokenizer.parseError(("Expecting ] or , but found " + token.value));
  4648.             };
  4649.             //unresolved jump
  4650.         }
  4651.         private function parseObject():Object{
  4652.             var _local2:String;
  4653.             var _local1:Object = new Object();
  4654.             nextToken();
  4655.             if (token.type == JSONTokenType.RIGHT_BRACE){
  4656.                 return (_local1);
  4657.             };
  4658.             if (token.type == JSONTokenType.STRING){
  4659.                 _local2 = String(token.value);
  4660.                 nextToken();
  4661.                 if (token.type == JSONTokenType.COLON){
  4662.                     nextToken();
  4663.                     _local1[_local2] = parseValue();
  4664.                     nextToken();
  4665.                     if (token.type == JSONTokenType.RIGHT_BRACE){
  4666.                         return (_local1);
  4667.                     };
  4668.                     if (token.type == JSONTokenType.COMMA){
  4669.                         nextToken();
  4670.                     } else {
  4671.                         tokenizer.parseError(("Expecting } or , but found " + token.value));
  4672.                     };
  4673.                 } else {
  4674.                     tokenizer.parseError(("Expecting : but found " + token.value));
  4675.                 };
  4676.             } else {
  4677.                 tokenizer.parseError(("Expecting string but found " + token.value));
  4678.             };
  4679.             //unresolved jump
  4680.         }
  4681.         private function parseValue():Object{
  4682.             switch (token.type){
  4683.                 case JSONTokenType.LEFT_BRACE:
  4684.                     return (parseObject());
  4685.                 case JSONTokenType.LEFT_BRACKET:
  4686.                     return (parseArray());
  4687.                 case JSONTokenType.STRING:
  4688.                 case JSONTokenType.NUMBER:
  4689.                 case JSONTokenType.TRUE:
  4690.                 case JSONTokenType.FALSE:
  4691.                 case JSONTokenType.NULL:
  4692.                     return (token.value);
  4693.                 default:
  4694.                     tokenizer.parseError(("Unexpected " + token.value));
  4695.             };
  4696.             return (null);
  4697.         }
  4698.  
  4699.     }
  4700. }//package com.adobe.serialization.json
  4701. package com.adobe.serialization.json {
  4702.  
  4703.     public class JSON {
  4704.  
  4705.         public static function encode(_arg1:Object):String{
  4706.             var _local2:JSONEncoder = new JSONEncoder(_arg1);
  4707.             return (_local2.getString());
  4708.         }
  4709.         public static function decode(_arg1:String){
  4710.             var _local2:JSONDecoder = new JSONDecoder(_arg1);
  4711.             return (_local2.getValue());
  4712.         }
  4713.  
  4714.     }
  4715. }//package com.adobe.serialization.json
  4716. package com.adobe.utils {
  4717.  
  4718.     public class IntUtil {
  4719.  
  4720.         private static var hexChars:String = "0123456789abcdef";
  4721.  
  4722.         public static function rol(_arg1:int, _arg2:int):int{
  4723.             return (((_arg1 << _arg2) | (_arg1 >>> (32 - _arg2))));
  4724.         }
  4725.         public static function ror(_arg1:int, _arg2:int):uint{
  4726.             var _local3:int = (32 - _arg2);
  4727.             return (((_arg1 << _local3) | (_arg1 >>> (32 - _local3))));
  4728.         }
  4729.         public static function toHex(_arg1:int, _arg2:Boolean=false):String{
  4730.             var _local4:int;
  4731.             var _local5:int;
  4732.             var _local3 = "";
  4733.             if (_arg2){
  4734.                 _local4 = 0;
  4735.                 while (_local4 < 4) {
  4736.                     _local3 = (_local3 + (hexChars.charAt(((_arg1 >> (((3 - _local4) * 8) + 4)) & 15)) + hexChars.charAt(((_arg1 >> ((3 - _local4) * 8)) & 15))));
  4737.                     _local4++;
  4738.                 };
  4739.             } else {
  4740.                 _local5 = 0;
  4741.                 while (_local5 < 4) {
  4742.                     _local3 = (_local3 + (hexChars.charAt(((_arg1 >> ((_local5 * 8) + 4)) & 15)) + hexChars.charAt(((_arg1 >> (_local5 * 8)) & 15))));
  4743.                     _local5++;
  4744.                 };
  4745.             };
  4746.             return (_local3);
  4747.         }
  4748.  
  4749.     }
  4750. }//package com.adobe.utils
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!