home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / alaskan-adversary.swf / scripts / %3Cdefault package%3E / UIObjectExtensions.as < prev   
Encoding:
Text File  |  2008-09-11  |  54.1 KB  |  1,002 lines
  1. function ┬º\x01\x02┬º()
  2. {
  3.    return 2204 % 511 * 5;
  4. }
  5. var ┬º\x01┬º = -30 + "\x01\x02"();
  6. loop0:
  7. while(true)
  8. {
  9.    if(eval("\x01") == 770)
  10.    {
  11.       set("\x01",eval("\x01") + 20);
  12.       ┬º┬ºpush(true);
  13.       continue;
  14.    }
  15.    if(eval("\x01") != 141)
  16.    {
  17.       if(eval("\x01") == 107)
  18.       {
  19.          set("\x01",eval("\x01") + 576);
  20.          ┬º┬ºpush(eval(function ┬º\x01\x02┬º()
  21.          {
  22.             return 2204 % 511 * 5;
  23.          }));
  24.       }
  25.       else if(eval("\x01") == 790)
  26.       {
  27.          set("\x01",eval("\x01") - 649);
  28.          if(function ┬º\x01\x02┬º()
  29.          {
  30.             return 2204 % 511 * 5;
  31.          })
  32.          {
  33.             set("\x01",eval("\x01") + 586);
  34.          }
  35.       }
  36.       else if(eval("\x01") == 683)
  37.       {
  38.          set("\x01",eval("\x01") - 537);
  39.          ┬º┬ºpush(!function ┬º\x01\x02┬º()
  40.          {
  41.             return 2204 % 511 * 5;
  42.          });
  43.       }
  44.       else if(eval("\x01") == 229)
  45.       {
  46.          set("\x01",eval("\x01") + 287);
  47.          var ┬º┬ºpop() = function ┬º\x01\x02┬º()
  48.          {
  49.             return 2204 % 511 * 5;
  50.          };
  51.       }
  52.       else if(eval("\x01") == 516)
  53.       {
  54.          set("\x01",eval("\x01") - 409);
  55.          ┬º┬ºpush("\x0f");
  56.       }
  57.       else if(eval("\x01") == 727)
  58.       {
  59.          set("\x01",eval("\x01") - 594);
  60.       }
  61.       else if(eval("\x01") == 146)
  62.       {
  63.          set("\x01",eval("\x01") - 84);
  64.          if(function ┬º\x01\x02┬º()
  65.          {
  66.             return 2204 % 511 * 5;
  67.          })
  68.          {
  69.             set("\x01",eval("\x01") + 0);
  70.          }
  71.       }
  72.       else if(eval("\x01") == 133)
  73.       {
  74.          set("\x01",eval("\x01") + 96);
  75.          ┬º┬ºpush("\x0f");
  76.          ┬º┬ºpush(1);
  77.       }
  78.       else
  79.       {
  80.          if(eval("\x01") == 62)
  81.          {
  82.             set("\x01",eval("\x01") + 204);
  83.             Object.registerClass("UIObjectExtensions",mx.core.ext.UIObjectExtensions);
  84.             break;
  85.          }
  86.          if(eval("\x01") != 987)
  87.          {
  88.             if(eval("\x01") == 266)
  89.             {
  90.                set("\x01",eval("\x01") - 266);
  91.             }
  92.             break;
  93.          }
  94.          set("\x01",eval("\x01") - 854);
  95.       }
  96.       continue;
  97.    }
  98.    set("\x01",eval("\x01") + 586);
  99.    while(true)
  100.    {
  101.       while(true)
  102.       {
  103.          if(eval("\x01") == 855)
  104.          {
  105.             set("\x01",eval("\x01") - 654);
  106.             ┬º┬ºpush(true);
  107.          }
  108.          else if(eval("\x01") == 201)
  109.          {
  110.             set("\x01",eval("\x01") + 706);
  111.             if(function ┬º\x01\x02┬º()
  112.             {
  113.                return 2204 % 511 * 5;
  114.             })
  115.             {
  116.                set("\x01",eval("\x01") - 845);
  117.             }
  118.          }
  119.          else if(eval("\x01") == 466)
  120.          {
  121.             set("\x01",eval("\x01") - 321);
  122.             var ┬º┬ºpop() = function ┬º\x01\x02┬º()
  123.             {
  124.                return 2204 % 511 * 5;
  125.             };
  126.          }
  127.          else if(eval("\x01") == 145)
  128.          {
  129.             set("\x01",eval("\x01") - 50);
  130.             ┬º┬ºpush("\x0f");
  131.          }
  132.          else if(eval("\x01") == 95)
  133.          {
  134.             set("\x01",eval("\x01") + 843);
  135.             ┬º┬ºpush(eval(function ┬º\x01\x02┬º()
  136.             {
  137.                return 2204 % 511 * 5;
  138.             }));
  139.          }
  140.          else if(eval("\x01") == 500)
  141.          {
  142.             set("\x01",eval("\x01") + 106);
  143.             if(function ┬º\x01\x02┬º()
  144.             {
  145.                return 2204 % 511 * 5;
  146.             })
  147.             {
  148.                set("\x01",eval("\x01") + 209);
  149.             }
  150.          }
  151.          else if(eval("\x01") == 479)
  152.          {
  153.             set("\x01",eval("\x01") - 13);
  154.             ┬º┬ºpush("\x0f");
  155.             ┬º┬ºpush(1);
  156.          }
  157.          else if(eval("\x01") == 938)
  158.          {
  159.             set("\x01",eval("\x01") - 438);
  160.             ┬º┬ºpush(!function ┬º\x01\x02┬º()
  161.             {
  162.                return 2204 % 511 * 5;
  163.             });
  164.          }
  165.          else if(eval("\x01") == 972)
  166.          {
  167.             set("\x01",eval("\x01") - 493);
  168.          }
  169.          else
  170.          {
  171.             if(eval("\x01") == 62)
  172.             {
  173.                break;
  174.             }
  175.             if(eval("\x01") == 907)
  176.             {
  177.                set("\x01",eval("\x01") - 845);
  178.                ┬º┬ºpop() extends ┬º┬ºpop() >> (┬º┬ºpop() | function ┬º\x01\x02┬º()
  179.                {
  180.                   return 2204 % 511 * 5;
  181.                });
  182.                ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  183.                break loop0;
  184.             }
  185.             if(eval("\x01") != 606)
  186.             {
  187.                if(eval("\x01") == 815)
  188.                {
  189.                   set("\x01",eval("\x01") - 396);
  190.                   if(!_global.mx)
  191.                   {
  192.                      _global.mx = new Object();
  193.                   }
  194.                   function ┬º\x01\x02┬º()
  195.                   {
  196.                      return 2204 % 511 * 5;
  197.                   }
  198.                   if(!_global.mx.managers)
  199.                   {
  200.                      _global.mx.managers = new Object();
  201.                   }
  202.                   ┬º┬ºpop();
  203.                   if(!_global.mx.managers.DepthManager)
  204.                   {
  205.                      var _loc2_ = mx.managers.DepthManager = function()
  206.                      {
  207.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  208.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  209.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  210.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  211.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  212.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  213.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  214.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  215.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  216.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  217.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  218.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  219.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  220.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  221.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  222.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  223.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  224.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  225.                      }.prototype;
  226.                      mx.managers.DepthManager = function()
  227.                      {
  228.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  229.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  230.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  231.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  232.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  233.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  234.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  235.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  236.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  237.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  238.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  239.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  240.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  241.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  242.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  243.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  244.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  245.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  246.                      }.sortFunction = function(a, b)
  247.                      {
  248.                         if(a.getDepth() > b.getDepth())
  249.                         {
  250.                            return 1;
  251.                         }
  252.                         return -1;
  253.                      };
  254.                      mx.managers.DepthManager = function()
  255.                      {
  256.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  257.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  258.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  259.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  260.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  261.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  262.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  263.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  264.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  265.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  266.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  267.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  268.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  269.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  270.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  271.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  272.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  273.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  274.                      }.test = function(depth)
  275.                      {
  276.                         if(depth == mx.managers.DepthManager.reservedDepth)
  277.                         {
  278.                            return false;
  279.                         }
  280.                         return true;
  281.                      };
  282.                      mx.managers.DepthManager = function()
  283.                      {
  284.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  285.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  286.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  287.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  288.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  289.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  290.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  291.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  292.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  293.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  294.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  295.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  296.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  297.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  298.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  299.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  300.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  301.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  302.                      }.createClassObjectAtDepth = function(className, depthSpace, initObj)
  303.                      {
  304.                         var _loc1_ = undefined;
  305.                         switch(depthSpace)
  306.                         {
  307.                            case mx.managers.DepthManager.kCursor:
  308.                               _loc1_ = mx.managers.DepthManager.holder.createClassChildAtDepth(className,mx.managers.DepthManager.kTopmost,initObj);
  309.                               break;
  310.                            case mx.managers.DepthManager.kTooltip:
  311.                               _loc1_ = mx.managers.DepthManager.holder.createClassChildAtDepth(className,mx.managers.DepthManager.kTop,initObj);
  312.                         }
  313.                         return _loc1_;
  314.                      };
  315.                      mx.managers.DepthManager = function()
  316.                      {
  317.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  318.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  319.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  320.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  321.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  322.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  323.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  324.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  325.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  326.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  327.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  328.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  329.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  330.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  331.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  332.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  333.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  334.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  335.                      }.createObjectAtDepth = function(linkageName, depthSpace, initObj)
  336.                      {
  337.                         var _loc1_ = undefined;
  338.                         switch(depthSpace)
  339.                         {
  340.                            case mx.managers.DepthManager.kCursor:
  341.                               _loc1_ = mx.managers.DepthManager.holder.createChildAtDepth(linkageName,mx.managers.DepthManager.kTopmost,initObj);
  342.                               break;
  343.                            case mx.managers.DepthManager.kTooltip:
  344.                               _loc1_ = mx.managers.DepthManager.holder.createChildAtDepth(linkageName,mx.managers.DepthManager.kTop,initObj);
  345.                         }
  346.                         return _loc1_;
  347.                      };
  348.                      _loc2_.createClassChildAtDepth = function(className, depthFlag, initObj)
  349.                      {
  350.                         if(this._childCounter == undefined)
  351.                         {
  352.                            this._childCounter = 0;
  353.                         }
  354.                         var _loc3_ = this.buildDepthTable();
  355.                         var _loc2_ = this.getDepthByFlag(depthFlag,_loc3_);
  356.                         var _loc6_ = "down";
  357.                         if(depthFlag == mx.managers.DepthManager.kBottom)
  358.                         {
  359.                            _loc6_ = "up";
  360.                         }
  361.                         var _loc5_ = undefined;
  362.                         if(_loc3_[_loc2_] != undefined)
  363.                         {
  364.                            _loc5_ = _loc2_;
  365.                            _loc2_ = this.findNextAvailableDepth(_loc2_,_loc3_,_loc6_);
  366.                         }
  367.                         var _loc4_ = this.createClassObject(className,"depthChild" + this._childCounter++,_loc2_,initObj);
  368.                         if(_loc5_ != undefined)
  369.                         {
  370.                            _loc3_[_loc2_] = _loc4_;
  371.                            this.shuffleDepths(_loc4_,_loc5_,_loc3_,_loc6_);
  372.                         }
  373.                         if(depthFlag == mx.managers.DepthManager.kTopmost)
  374.                         {
  375.                            _loc4_._topmost = true;
  376.                         }
  377.                         return _loc4_;
  378.                      };
  379.                      _loc2_.createChildAtDepth = function(linkageName, depthFlag, initObj)
  380.                      {
  381.                         if(this._childCounter == undefined)
  382.                         {
  383.                            this._childCounter = 0;
  384.                         }
  385.                         var _loc3_ = this.buildDepthTable();
  386.                         var _loc2_ = this.getDepthByFlag(depthFlag,_loc3_);
  387.                         var _loc6_ = "down";
  388.                         if(depthFlag == mx.managers.DepthManager.kBottom)
  389.                         {
  390.                            _loc6_ = "up";
  391.                         }
  392.                         var _loc5_ = undefined;
  393.                         if(_loc3_[_loc2_] != undefined)
  394.                         {
  395.                            _loc5_ = _loc2_;
  396.                            _loc2_ = this.findNextAvailableDepth(_loc2_,_loc3_,_loc6_);
  397.                         }
  398.                         var _loc4_ = this.createObject(linkageName,"depthChild" + this._childCounter++,_loc2_,initObj);
  399.                         if(_loc5_ != undefined)
  400.                         {
  401.                            _loc3_[_loc2_] = _loc4_;
  402.                            this.shuffleDepths(_loc4_,_loc5_,_loc3_,_loc6_);
  403.                         }
  404.                         if(depthFlag == mx.managers.DepthManager.kTopmost)
  405.                         {
  406.                            _loc4_._topmost = true;
  407.                         }
  408.                         return _loc4_;
  409.                      };
  410.                      _loc2_.setDepthTo = function(depthFlag)
  411.                      {
  412.                         var _loc2_ = this._parent.buildDepthTable();
  413.                         var _loc3_ = this._parent.getDepthByFlag(depthFlag,_loc2_);
  414.                         if(_loc2_[_loc3_] != undefined)
  415.                         {
  416.                            this.shuffleDepths(this,_loc3_,_loc2_,undefined);
  417.                         }
  418.                         else
  419.                         {
  420.                            this.swapDepths(_loc3_);
  421.                         }
  422.                         if(depthFlag == mx.managers.DepthManager.kTopmost)
  423.                         {
  424.                            this._topmost = true;
  425.                         }
  426.                         else
  427.                         {
  428.                            delete this._topmost;
  429.                         }
  430.                      };
  431.                      _loc2_.setDepthAbove = function(targetInstance)
  432.                      {
  433.                         if(targetInstance._parent != this._parent)
  434.                         {
  435.                            return undefined;
  436.                         }
  437.                         var _loc2_ = targetInstance.getDepth() + 1;
  438.                         var _loc3_ = this._parent.buildDepthTable();
  439.                         if(_loc3_[_loc2_] != undefined && this.getDepth() < _loc2_)
  440.                         {
  441.                            _loc2_ -= 1;
  442.                         }
  443.                         if(_loc2_ > mx.managers.DepthManager.highestDepth)
  444.                         {
  445.                            _loc2_ = mx.managers.DepthManager.highestDepth;
  446.                         }
  447.                         if(_loc2_ == mx.managers.DepthManager.highestDepth)
  448.                         {
  449.                            this._parent.shuffleDepths(this,_loc2_,_loc3_,"down");
  450.                         }
  451.                         else if(_loc3_[_loc2_] != undefined)
  452.                         {
  453.                            this._parent.shuffleDepths(this,_loc2_,_loc3_,undefined);
  454.                         }
  455.                         else
  456.                         {
  457.                            this.swapDepths(_loc2_);
  458.                         }
  459.                      };
  460.                      _loc2_.setDepthBelow = function(targetInstance)
  461.                      {
  462.                         if(targetInstance._parent != this._parent)
  463.                         {
  464.                            return undefined;
  465.                         }
  466.                         var _loc6_ = targetInstance.getDepth() - 1;
  467.                         var _loc3_ = this._parent.buildDepthTable();
  468.                         if(_loc3_[_loc6_] != undefined && this.getDepth() > _loc6_)
  469.                         {
  470.                            _loc6_ += 1;
  471.                         }
  472.                         var _loc4_ = mx.managers.DepthManager.lowestDepth + mx.managers.DepthManager.numberOfAuthortimeLayers;
  473.                         var _loc5_ = undefined;
  474.                         for(_loc5_ in _loc3_)
  475.                         {
  476.                            var _loc2_ = _loc3_[_loc5_];
  477.                            if(_loc2_._parent != undefined)
  478.                            {
  479.                               _loc4_ = Math.min(_loc4_,_loc2_.getDepth());
  480.                            }
  481.                         }
  482.                         if(_loc6_ < _loc4_)
  483.                         {
  484.                            _loc6_ = _loc4_;
  485.                         }
  486.                         if(_loc6_ == _loc4_)
  487.                         {
  488.                            this._parent.shuffleDepths(this,_loc6_,_loc3_,"up");
  489.                         }
  490.                         else if(_loc3_[_loc6_] != undefined)
  491.                         {
  492.                            this._parent.shuffleDepths(this,_loc6_,_loc3_,undefined);
  493.                         }
  494.                         else
  495.                         {
  496.                            this.swapDepths(_loc6_);
  497.                         }
  498.                      };
  499.                      _loc2_.findNextAvailableDepth = function(targetDepth, depthTable, direction)
  500.                      {
  501.                         var _loc5_ = mx.managers.DepthManager.lowestDepth + mx.managers.DepthManager.numberOfAuthortimeLayers;
  502.                         if(targetDepth < _loc5_)
  503.                         {
  504.                            targetDepth = _loc5_;
  505.                         }
  506.                         if(depthTable[targetDepth] == undefined)
  507.                         {
  508.                            return targetDepth;
  509.                         }
  510.                         var _loc2_ = targetDepth;
  511.                         var _loc1_ = targetDepth;
  512.                         if(direction == "down")
  513.                         {
  514.                            while(depthTable[_loc1_] != undefined)
  515.                            {
  516.                               _loc1_ = _loc1_ - 1;
  517.                            }
  518.                            return _loc1_;
  519.                         }
  520.                         while(depthTable[_loc2_] != undefined)
  521.                         {
  522.                            _loc2_ = _loc2_ + 1;
  523.                         }
  524.                         return _loc2_;
  525.                      };
  526.                      _loc2_.shuffleDepths = function(subject, targetDepth, depthTable, direction)
  527.                      {
  528.                         var _loc9_ = mx.managers.DepthManager.lowestDepth + mx.managers.DepthManager.numberOfAuthortimeLayers;
  529.                         var _loc8_ = _loc9_;
  530.                         var _loc5_ = undefined;
  531.                         for(_loc5_ in depthTable)
  532.                         {
  533.                            var _loc7_ = depthTable[_loc5_];
  534.                            if(_loc7_._parent != undefined)
  535.                            {
  536.                               _loc9_ = Math.min(_loc9_,_loc7_.getDepth());
  537.                            }
  538.                         }
  539.                         if(direction == undefined)
  540.                         {
  541.                            if(subject.getDepth() > targetDepth)
  542.                            {
  543.                               direction = "up";
  544.                            }
  545.                            else
  546.                            {
  547.                               direction = "down";
  548.                            }
  549.                         }
  550.                         var _loc1_ = new Array();
  551.                         for(_loc5_ in depthTable)
  552.                         {
  553.                            _loc7_ = depthTable[_loc5_];
  554.                            if(_loc7_._parent != undefined)
  555.                            {
  556.                               _loc1_.push(_loc7_);
  557.                            }
  558.                         }
  559.                         _loc1_.sort(mx.managers.DepthManager.sortFunction);
  560.                         if(direction == "up")
  561.                         {
  562.                            var _loc3_ = undefined;
  563.                            var _loc11_ = undefined;
  564.                            while(_loc1_.length > 0)
  565.                            {
  566.                               _loc3_ = _loc1_.pop();
  567.                               if(_loc3_ == subject)
  568.                               {
  569.                                  break;
  570.                               }
  571.                            }
  572.                            while(_loc1_.length > 0)
  573.                            {
  574.                               _loc11_ = subject.getDepth();
  575.                               _loc3_ = _loc1_.pop();
  576.                               var _loc4_ = _loc3_.getDepth();
  577.                               if(_loc11_ > _loc4_ + 1)
  578.                               {
  579.                                  if(_loc4_ >= 0)
  580.                                  {
  581.                                     subject.swapDepths(_loc4_ + 1);
  582.                                  }
  583.                                  else if(_loc11_ > _loc8_ && _loc4_ < _loc8_)
  584.                                  {
  585.                                     subject.swapDepths(_loc8_);
  586.                                  }
  587.                               }
  588.                               subject.swapDepths(_loc3_);
  589.                               if(_loc4_ == targetDepth)
  590.                               {
  591.                                  break;
  592.                               }
  593.                            }
  594.                         }
  595.                         else if(direction == "down")
  596.                         {
  597.                            _loc3_ = undefined;
  598.                            while(_loc1_.length > 0)
  599.                            {
  600.                               _loc3_ = _loc1_.shift();
  601.                               if(_loc3_ == subject)
  602.                               {
  603.                                  break;
  604.                               }
  605.                            }
  606.                            while(_loc1_.length > 0)
  607.                            {
  608.                               _loc11_ = _loc3_.getDepth();
  609.                               _loc3_ = _loc1_.shift();
  610.                               _loc4_ = _loc3_.getDepth();
  611.                               if(_loc11_ < _loc4_ - 1 && _loc4_ > 0)
  612.                               {
  613.                                  subject.swapDepths(_loc4_ - 1);
  614.                               }
  615.                               subject.swapDepths(_loc3_);
  616.                               if(_loc4_ == targetDepth)
  617.                               {
  618.                                  break;
  619.                               }
  620.                            }
  621.                         }
  622.                      };
  623.                      _loc2_.getDepthByFlag = function(depthFlag, depthTable)
  624.                      {
  625.                         var _loc2_ = 0;
  626.                         if(depthFlag == mx.managers.DepthManager.kTop || depthFlag == mx.managers.DepthManager.kNotopmost)
  627.                         {
  628.                            var _loc5_ = 0;
  629.                            var _loc7_ = false;
  630.                            var _loc8_ = undefined;
  631.                            for(_loc8_ in depthTable)
  632.                            {
  633.                               var _loc9_ = depthTable[_loc8_];
  634.                               var _loc3_ = typeof _loc9_;
  635.                               if(_loc3_ == "movieclip" || _loc3_ == "object" && _loc9_.__getTextFormat != undefined)
  636.                               {
  637.                                  if(_loc9_.getDepth() <= mx.managers.DepthManager.highestDepth)
  638.                                  {
  639.                                     if(!_loc9_._topmost)
  640.                                     {
  641.                                        _loc2_ = Math.max(_loc2_,_loc9_.getDepth());
  642.                                     }
  643.                                     else if(!_loc7_)
  644.                                     {
  645.                                        _loc5_ = _loc9_.getDepth();
  646.                                        _loc7_ = true;
  647.                                     }
  648.                                     else
  649.                                     {
  650.                                        _loc5_ = Math.min(_loc5_,_loc9_.getDepth());
  651.                                     }
  652.                                  }
  653.                               }
  654.                            }
  655.                            _loc2_ += 20;
  656.                            if(_loc7_)
  657.                            {
  658.                               if(_loc2_ >= _loc5_)
  659.                               {
  660.                                  _loc2_ = _loc5_ - 1;
  661.                               }
  662.                            }
  663.                         }
  664.                         else if(depthFlag == mx.managers.DepthManager.kBottom)
  665.                         {
  666.                            for(_loc8_ in depthTable)
  667.                            {
  668.                               _loc9_ = depthTable[_loc8_];
  669.                               _loc3_ = typeof _loc9_;
  670.                               if(_loc3_ == "movieclip" || _loc3_ == "object" && _loc9_.__getTextFormat != undefined)
  671.                               {
  672.                                  if(_loc9_.getDepth() <= mx.managers.DepthManager.highestDepth)
  673.                                  {
  674.                                     _loc2_ = Math.min(_loc2_,_loc9_.getDepth());
  675.                                  }
  676.                               }
  677.                            }
  678.                            _loc2_ -= 20;
  679.                         }
  680.                         else if(depthFlag == mx.managers.DepthManager.kTopmost)
  681.                         {
  682.                            for(_loc8_ in depthTable)
  683.                            {
  684.                               _loc9_ = depthTable[_loc8_];
  685.                               _loc3_ = typeof _loc9_;
  686.                               if(_loc3_ == "movieclip" || _loc3_ == "object" && _loc9_.__getTextFormat != undefined)
  687.                               {
  688.                                  if(_loc9_.getDepth() <= mx.managers.DepthManager.highestDepth)
  689.                                  {
  690.                                     _loc2_ = Math.max(_loc2_,_loc9_.getDepth());
  691.                                  }
  692.                               }
  693.                            }
  694.                            _loc2_ += 100;
  695.                         }
  696.                         if(_loc2_ >= mx.managers.DepthManager.highestDepth)
  697.                         {
  698.                            _loc2_ = mx.managers.DepthManager.highestDepth;
  699.                         }
  700.                         var _loc6_ = mx.managers.DepthManager.lowestDepth + mx.managers.DepthManager.numberOfAuthortimeLayers;
  701.                         for(_loc9_ in depthTable)
  702.                         {
  703.                            var _loc4_ = depthTable[_loc9_];
  704.                            if(_loc4_._parent != undefined)
  705.                            {
  706.                               _loc6_ = Math.min(_loc6_,_loc4_.getDepth());
  707.                            }
  708.                         }
  709.                         if(_loc2_ <= _loc6_)
  710.                         {
  711.                            _loc2_ = _loc6_;
  712.                         }
  713.                         return _loc2_;
  714.                      };
  715.                      _loc2_.buildDepthTable = function(Void)
  716.                      {
  717.                         var _loc5_ = new Array();
  718.                         var _loc4_ = undefined;
  719.                         for(_loc4_ in this)
  720.                         {
  721.                            var _loc2_ = this[_loc4_];
  722.                            var _loc3_ = typeof _loc2_;
  723.                            if(_loc3_ == "movieclip" || _loc3_ == "object" && _loc2_.__getTextFormat != undefined)
  724.                            {
  725.                               if(_loc2_._parent == this)
  726.                               {
  727.                                  _loc5_[_loc2_.getDepth()] = _loc2_;
  728.                               }
  729.                            }
  730.                         }
  731.                         return _loc5_;
  732.                      };
  733.                      mx.managers.DepthManager = function()
  734.                      {
  735.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  736.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  737.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  738.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  739.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  740.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  741.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  742.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  743.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  744.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  745.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  746.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  747.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  748.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  749.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  750.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  751.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  752.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  753.                      }.reservedDepth = 1048575;
  754.                      mx.managers.DepthManager = function()
  755.                      {
  756.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  757.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  758.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  759.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  760.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  761.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  762.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  763.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  764.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  765.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  766.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  767.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  768.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  769.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  770.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  771.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  772.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  773.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  774.                      }.highestDepth = 1048574;
  775.                      mx.managers.DepthManager = function()
  776.                      {
  777.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  778.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  779.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  780.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  781.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  782.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  783.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  784.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  785.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  786.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  787.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  788.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  789.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  790.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  791.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  792.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  793.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  794.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  795.                      }.lowestDepth = -16383;
  796.                      mx.managers.DepthManager = function()
  797.                      {
  798.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  799.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  800.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  801.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  802.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  803.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  804.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  805.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  806.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  807.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  808.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  809.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  810.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  811.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  812.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  813.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  814.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  815.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  816.                      }.numberOfAuthortimeLayers = 383;
  817.                      mx.managers.DepthManager = function()
  818.                      {
  819.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  820.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  821.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  822.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  823.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  824.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  825.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  826.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  827.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  828.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  829.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  830.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  831.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  832.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  833.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  834.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  835.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  836.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  837.                      }.kCursor = 101;
  838.                      mx.managers.DepthManager = function()
  839.                      {
  840.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  841.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  842.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  843.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  844.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  845.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  846.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  847.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  848.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  849.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  850.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  851.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  852.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  853.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  854.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  855.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  856.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  857.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  858.                      }.kTooltip = 102;
  859.                      mx.managers.DepthManager = function()
  860.                      {
  861.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  862.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  863.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  864.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  865.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  866.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  867.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  868.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  869.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  870.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  871.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  872.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  873.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  874.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  875.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  876.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  877.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  878.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  879.                      }.kTop = 201;
  880.                      mx.managers.DepthManager = function()
  881.                      {
  882.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  883.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  884.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  885.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  886.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  887.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  888.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  889.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  890.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  891.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  892.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  893.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  894.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  895.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  896.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  897.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  898.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  899.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  900.                      }.kBottom = 202;
  901.                      mx.managers.DepthManager = function()
  902.                      {
  903.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  904.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  905.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  906.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  907.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  908.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  909.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  910.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  911.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  912.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  913.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  914.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  915.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  916.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  917.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  918.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  919.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  920.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  921.                      }.kTopmost = 203;
  922.                      mx.managers.DepthManager = function()
  923.                      {
  924.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  925.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  926.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  927.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  928.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  929.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  930.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  931.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  932.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  933.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  934.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  935.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  936.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  937.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  938.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  939.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  940.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  941.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  942.                      }.kNotopmost = 204;
  943.                      mx.managers.DepthManager = function()
  944.                      {
  945.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  946.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  947.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  948.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  949.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  950.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  951.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  952.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  953.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  954.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  955.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  956.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  957.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  958.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  959.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  960.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  961.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  962.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  963.                      }.holder = _root.createEmptyMovieClip("reserved",mx.managers.DepthManager.reservedDepth);
  964.                      mx.managers.DepthManager = function()
  965.                      {
  966.                         MovieClip.prototype.createClassChildAtDepth = this.createClassChildAtDepth;
  967.                         MovieClip.prototype.createChildAtDepth = this.createChildAtDepth;
  968.                         MovieClip.prototype.setDepthTo = this.setDepthTo;
  969.                         MovieClip.prototype.setDepthAbove = this.setDepthAbove;
  970.                         MovieClip.prototype.setDepthBelow = this.setDepthBelow;
  971.                         MovieClip.prototype.findNextAvailableDepth = this.findNextAvailableDepth;
  972.                         MovieClip.prototype.shuffleDepths = this.shuffleDepths;
  973.                         MovieClip.prototype.getDepthByFlag = this.getDepthByFlag;
  974.                         MovieClip.prototype.buildDepthTable = this.buildDepthTable;
  975.                         _global.ASSetPropFlags(MovieClip.prototype,"createClassChildAtDepth",1);
  976.                         _global.ASSetPropFlags(MovieClip.prototype,"createChildAtDepth",1);
  977.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthTo",1);
  978.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthAbove",1);
  979.                         _global.ASSetPropFlags(MovieClip.prototype,"setDepthBelow",1);
  980.                         _global.ASSetPropFlags(MovieClip.prototype,"findNextAvailableDepth",1);
  981.                         _global.ASSetPropFlags(MovieClip.prototype,"shuffleDepths",1);
  982.                         _global.ASSetPropFlags(MovieClip.prototype,"getDepthByFlag",1);
  983.                         _global.ASSetPropFlags(MovieClip.prototype,"buildDepthTable",1);
  984.                      }.__depthManager = new mx.managers.DepthManager();
  985.                      ┬º┬ºpush(ASSetPropFlags(mx.managers.DepthManager.prototype,null,1));
  986.                   }
  987.                   ┬º┬ºpop();
  988.                   break loop0;
  989.                }
  990.                if(eval("\x01") == 419)
  991.                {
  992.                   set("\x01",eval("\x01") - 419);
  993.                }
  994.                break loop0;
  995.             }
  996.             set("\x01",eval("\x01") + 209);
  997.          }
  998.       }
  999.       set("\x01",eval("\x01") + 417);
  1000.    }
  1001. }
  1002.