home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Acao / fwg_knight.swf / scripts / __Packages / Common.as < prev    next >
Encoding:
Text File  |  2008-08-28  |  18.2 KB  |  653 lines
  1. class Common
  2. {
  3.    var mClip_bmp;
  4.    var bmpRoot;
  5.    var removeMovieClip;
  6.    var nTime;
  7.    var ready;
  8.    var nTemp;
  9.    var nT;
  10.    var nRdm;
  11.    var m_0;
  12.    var m_1;
  13.    var finish;
  14.    var onEnterFrame;
  15.    var nRdm_2;
  16.    var m_2;
  17.    var m_3;
  18.    var nTemp_time;
  19.    var _alpha;
  20.    var nN;
  21.    static var a2r = 57.29577951308232;
  22.    function Common()
  23.    {
  24.    }
  25.    static function enabledFor(_b, _m, _mHit, _nDepth)
  26.    {
  27.       _m == undefined && (_m = _root);
  28.       _mHit == undefined && (_mHit = _root);
  29.       _nDepth == undefined && (_nDepth = _m.getNextHighestDepth());
  30.       if(_b)
  31.       {
  32.          _m.createEmptyMovieClip("mEnabled",_nDepth);
  33.          _m.mEnabled.enabled = false;
  34.          _m.mEnabled.hitArea = _mHit;
  35.          _m.mEnabled.onPress = function()
  36.          {
  37.          };
  38.          updateAfterEvent();
  39.       }
  40.       else
  41.       {
  42.          _m.mEnabled.removeMovieClip();
  43.          updateAfterEvent();
  44.       }
  45.    }
  46.    static function changeQ()
  47.    {
  48.       switch(_root._quality)
  49.       {
  50.          case "LOW":
  51.             _root._quality = "MEDIUM";
  52.             return "MED";
  53.          case "MEDIUM":
  54.             _root._quality = "HIGH";
  55.             break;
  56.          case "HIGH":
  57.             _root._quality = "BEST";
  58.             break;
  59.          case "BEST":
  60.             _root._quality = "LOW";
  61.       }
  62.       return _root._quality;
  63.    }
  64.    static function mask()
  65.    {
  66.       var bmpRoot = new flash.display.BitmapData(Stage.width,Stage.height,false,0);
  67.       bmpRoot.draw(_root);
  68.       var _loc3_ = _root.createEmptyMovieClip("mClip_mask",_root.getNextHighestDepth());
  69.       var mClip_bmp = _root.createEmptyMovieClip("mClip_bmp",_root.getNextHighestDepth());
  70.       mClip_bmp.attachBitmap(bmpRoot,0);
  71.       _loc3_.bmpRoot = bmpRoot;
  72.       _loc3_.mClip_bmp = mClip_bmp;
  73.       _loc3_.nTime = 0;
  74.       _loc3_.nT = 20;
  75.       _loc3_.ready = function()
  76.       {
  77.          this.mClip_bmp.setMask(this);
  78.          Common.enabledFor(true);
  79.       };
  80.       _loc3_.finish = function()
  81.       {
  82.          this.mClip_bmp.removeMovieClip();
  83.          this.bmpRoot.dispose();
  84.          Common.enabledFor(false);
  85.          this.removeMovieClip();
  86.       };
  87.       switch(random(4))
  88.       {
  89.          case 0:
  90.             _loc3_.nRdm = random(2);
  91.             Common.createClip("m_",_loc3_,0,0);
  92.             Common.createClip("m_",_loc3_,0,1,{_x:10,_y:10,_rotation:180});
  93.             _loc3_.onEnterFrame = function()
  94.             {
  95.                if(this.nTime == 0)
  96.                {
  97.                   this.ready();
  98.                }
  99.                this.nTime = this.nTime + 1;
  100.                this.nTemp = 50 - Common.unlinearCycle(this.nTime,this.nT,50);
  101.                if(this.nRdm > 0)
  102.                {
  103.                   this.m_0._yscale = this.m_1._yscale = this.nTemp;
  104.                }
  105.                else
  106.                {
  107.                   this.m_0._xscale = this.m_1._xscale = this.nTemp;
  108.                }
  109.                if(this.nTime == this.nT / 2)
  110.                {
  111.                   this.finish();
  112.                   delete this.onEnterFrame;
  113.                }
  114.             };
  115.             break;
  116.          case 1:
  117.             _loc3_.nRdm = random(3);
  118.             _loc3_.nRdm_2 = random(4);
  119.             Common.createClip("m_",_loc3_,1,0,{_x:5,_y:5});
  120.             _loc3_.onEnterFrame = function()
  121.             {
  122.                if(this.nTime == 0)
  123.                {
  124.                   this.ready();
  125.                }
  126.                this.nTime = this.nTime + 1;
  127.                this.nTemp = 100 - Common.unlinearCycle(this.nTime,this.nT,100);
  128.                switch(this.nRdm)
  129.                {
  130.                   case 0:
  131.                      this.m_0._xscale = 150;
  132.                      this.m_0._yscale = this.nTemp;
  133.                      break;
  134.                   case 1:
  135.                      this.m_0._xscale = this.nTemp;
  136.                      this.m_0._yscale = 150;
  137.                      break;
  138.                   case 2:
  139.                      this.m_0._yscale = _loc0_ = this.nTemp;
  140.                      this.m_0._xscale = _loc0_;
  141.                }
  142.                if(this.nRdm_2 == 3)
  143.                {
  144.                   this.m_0._rotation = 180 - Common.unlinearCycle(this.nTime,this.nT,180);
  145.                }
  146.                else if(this.nRdm_2 == 2)
  147.                {
  148.                   this.m_0._rotation = Common.unlinearCycle(this.nTime,this.nT,180);
  149.                }
  150.                if(this.nTime == this.nT / 2)
  151.                {
  152.                   this.finish();
  153.                   delete this.onEnterFrame;
  154.                }
  155.             };
  156.             break;
  157.          case 2:
  158.             _loc3_.nRdm = random(5);
  159.             Common.createClip("m_",_loc3_,2,0);
  160.             Common.createClip("m_",_loc3_,2,1,{_x:10,_y:10,_rotation:180});
  161.             _loc3_.onEnterFrame = function()
  162.             {
  163.                if(this.nTime == 0)
  164.                {
  165.                   this.ready();
  166.                }
  167.                this.nTime = this.nTime + 1;
  168.                this.nTemp = 100 - Common.unlinearCycle(this.nTime,this.nT,100);
  169.                switch(this.nRdm)
  170.                {
  171.                   case 0:
  172.                      this.m_1._yscale = _loc0_ = this.nTemp;
  173.                      this.m_0._yscale = _loc0_;
  174.                      break;
  175.                   case 1:
  176.                      this.m_1._yscale = _loc0_ = this.nTemp;
  177.                      this.m_0._xscale = _loc0_;
  178.                      break;
  179.                   case 2:
  180.                      this.m_1._xscale = _loc0_ = this.nTemp;
  181.                      this.m_0._yscale = _loc0_;
  182.                      break;
  183.                   case 3:
  184.                      this.m_1._xscale = _loc0_ = this.nTemp;
  185.                      this.m_0._xscale = _loc0_;
  186.                      break;
  187.                   case 4:
  188.                      this.m_1._xscale = _loc0_ = this.nTemp;
  189.                      this.m_0._xscale = _loc0_;
  190.                      this.m_1._yscale = _loc0_ = this.nTemp;
  191.                      this.m_0._yscale = _loc0_;
  192.                }
  193.                if(this.nTime == this.nT / 2)
  194.                {
  195.                   this.finish();
  196.                   delete this.onEnterFrame;
  197.                }
  198.             };
  199.             break;
  200.          case 3:
  201.             _loc3_.nRdm = random(2);
  202.             Common.createClip("m_",_loc3_,2,0);
  203.             Common.createClip("m_",_loc3_,2,1,{_x:10,_y:10,_rotation:180});
  204.             Common.createClip("m_",_loc3_,2,2,{_x:0,_y:10,_rotation:-90});
  205.             Common.createClip("m_",_loc3_,2,3,{_x:10,_y:0,_rotation:90});
  206.             _loc3_.onEnterFrame = function()
  207.             {
  208.                if(this.nTime == 0)
  209.                {
  210.                   this.ready();
  211.                }
  212.                this.nTime = this.nTime + 1;
  213.                this.nTemp = 100 - Common.unlinearCycle(this.nTime,this.nT,100);
  214.                if(this.nRdm > 0)
  215.                {
  216.                   this.m_0._yscale = this.m_1._yscale = this.m_2._yscale = this.m_3._yscale = this.nTemp;
  217.                }
  218.                else
  219.                {
  220.                   this.m_0._xscale = this.m_1._xscale = this.m_2._xscale = this.m_3._xscale = this.nTemp;
  221.                }
  222.                if(this.nTime == this.nT / 2)
  223.                {
  224.                   this.finish();
  225.                   delete this.onEnterFrame;
  226.                }
  227.             };
  228.       }
  229.       _loc3_._width = _loc0_ = Stage.width;
  230.       _loc0_;
  231.       _loc3_._height = _loc0_ = Stage.height;
  232.       _loc0_;
  233.    }
  234.    static function getBmdHitRect(bg, obj)
  235.    {
  236.       var _loc2_ = Common.getContainBmd(bg,obj,10,10);
  237.       _root.attachBitmap(_loc2_,0);
  238.       return _loc2_.getColorBoundsRect(4294967295,4278190080);
  239.    }
  240.    static function getContainBmd(bg, obj, bm1, bm2)
  241.    {
  242.       var _loc1_ = obj.getBounds(obj);
  243.       var _loc3_ = new flash.geom.Rectangle(_loc1_.xMin,_loc1_.yMin,_loc1_.xMax - _loc1_.xMin,_loc1_.yMax - _loc1_.yMin);
  244.       var _loc4_ = new flash.display.BitmapData(_loc3_.width,_loc3_.height,true,0);
  245.       var _loc6_ = bg.transform.concatenatedMatrix;
  246.       var _loc2_ = new flash.geom.Matrix(1,0,0,1,- _loc3_.x,- _loc3_.y);
  247.       _loc4_.draw(obj,_loc2_,null,bm1);
  248.       _loc2_.tx *= -1;
  249.       _loc2_.ty *= -1;
  250.       var _loc7_ = obj.transform.concatenatedMatrix;
  251.       _loc2_.concat(_loc7_);
  252.       _loc2_.invert();
  253.       _loc6_.concat(_loc2_);
  254.       _loc4_.draw(bg,_loc6_,null,bm2);
  255.       return _loc4_;
  256.    }
  257.    static function createClip(_s, _m, _nType, _nDepth, _ob)
  258.    {
  259.       _nDepth == undefined && (_nDepth = _m.getNextHighestDepth());
  260.       _nType == undefined && (_nType = 0);
  261.       _m.createEmptyMovieClip(_s + _nDepth,_nDepth);
  262.       _m[_s + _nDepth].beginFill(0);
  263.       switch(_nType)
  264.       {
  265.          case 0:
  266.             _m[_s + _nDepth].lineTo(10,0);
  267.             _m[_s + _nDepth].lineTo(10,10);
  268.             _m[_s + _nDepth].lineTo(0,10);
  269.             _m[_s + _nDepth].lineTo(0,0);
  270.             break;
  271.          case 1:
  272.             _m[_s + _nDepth].moveTo(-5,-5);
  273.             _m[_s + _nDepth].lineTo(-5,5);
  274.             _m[_s + _nDepth].lineTo(5,5);
  275.             _m[_s + _nDepth].lineTo(5,-5);
  276.             _m[_s + _nDepth].lineTo(-5,-5);
  277.             break;
  278.          case 2:
  279.             _m[_s + _nDepth].lineTo(10,0);
  280.             _m[_s + _nDepth].lineTo(0,10);
  281.             _m[_s + _nDepth].lineTo(0,0);
  282.       }
  283.       _m[_s + _nDepth].endFill();
  284.       for(var _loc5_ in _ob)
  285.       {
  286.          _m[_s + _nDepth][_loc5_] = _ob[_loc5_];
  287.       }
  288.       return _m[_s + _nDepth];
  289.    }
  290.    static function wink(_m, _T, _n)
  291.    {
  292.       _m.nTemp_time = 0;
  293.       _m.nT = _T;
  294.       _m.nN = _n;
  295.       _m.onEnterFrame = function()
  296.       {
  297.          this.nTemp_time = this.nTemp_time + 1;
  298.          this._alpha = 100 - Common.unlinearCycle(this.nTemp_time,this.nT,100);
  299.          if(this.nTemp_time >= this.nN * this.nT)
  300.          {
  301.             this._alpha = 100;
  302.             delete this.onEnterFrame;
  303.             delete this.nTemp_time;
  304.             delete this.nN;
  305.             delete this.nT;
  306.          }
  307.       };
  308.    }
  309.    static function addClip(_sId, _sName, _m, oBject, _nDepth)
  310.    {
  311.       _nDepth == undefined && (_nDepth = _m.getNextHighestDepth());
  312.       _sName == undefined && (_sName = _sId);
  313.       return _m.attachMovie(_sId,_sName + _nDepth,_nDepth,oBject);
  314.    }
  315.    static function clearAllClip(_m, _bAll)
  316.    {
  317.       for(var _loc3_ in _m)
  318.       {
  319.          if(_bAll)
  320.          {
  321.             _m[_loc3_].swapDepths(0);
  322.          }
  323.          _m[_loc3_].removeMovieClip();
  324.       }
  325.    }
  326.    static function removeFixMc(mc)
  327.    {
  328.       mc.swapDepths(mc._parent.getNextHighestDepth());
  329.       mc.removeMovieClip();
  330.    }
  331.    static function coordinateConvert(mc1, mc2, x, y)
  332.    {
  333.       var _loc2_ = new Object({x:(x == undefined ? 0 : x),y:(y == undefined ? 0 : y)});
  334.       mc1.localToGlobal(_loc2_);
  335.       if(mc2 != undefined && mc2 != _root)
  336.       {
  337.          mc2.globalToLocal(_loc2_);
  338.       }
  339.       return _loc2_;
  340.    }
  341.    static function localToLocal(p, mc1, mc2)
  342.    {
  343.       mc1.localToGlobal(p);
  344.       mc2.globalToLocal(p);
  345.    }
  346.    static function np(_n)
  347.    {
  348.       _n == undefined && (_n = 1);
  349.       return random(2) <= 0 ? - _n : _n;
  350.    }
  351.    static function rdm_2(a, b)
  352.    {
  353.       return Math.random() * (b - a) + a;
  354.    }
  355.    static function rdm_0(a, l)
  356.    {
  357.       return a - Math.random() * l + l / 2;
  358.    }
  359.    static function rdm_a(a1, a2, A)
  360.    {
  361.       var _loc3_ = 0;
  362.       var _loc5_ = Math.random();
  363.       var _loc4_ = 0;
  364.       var _loc2_ = A.concat();
  365.       for(var _loc6_ in _loc2_)
  366.       {
  367.          var _loc1_ = 0;
  368.          while(_loc1_ < Number(_loc6_))
  369.          {
  370.             _loc2_[_loc6_] += _loc2_[_loc1_];
  371.             _loc1_ = _loc1_ + 1;
  372.          }
  373.          _loc3_ < _loc2_[_loc6_] && (_loc3_ = _loc2_[_loc6_]);
  374.          _loc2_[_loc6_] /= _loc3_;
  375.          if(_loc5_ >= _loc2_[_loc6_])
  376.          {
  377.             _loc4_ = Number(_loc6_) + 1;
  378.             break;
  379.          }
  380.       }
  381.       return a1 + _loc4_ * (a2 - a1) / (_loc2_.length - 1);
  382.    }
  383.    static function equal(_ob1, _ob2)
  384.    {
  385.       for(var _loc3_ in _ob1)
  386.       {
  387.          if(_ob1[_loc3_] != _ob2[_loc3_])
  388.          {
  389.             return false;
  390.          }
  391.       }
  392.       return true;
  393.    }
  394.    static function formatNumber(_n, _d, _nMin, _nMax)
  395.    {
  396.       _n += _d;
  397.       if(_n < _nMin)
  398.       {
  399.          _n = _nMin;
  400.       }
  401.       else if(_n > _nMax)
  402.       {
  403.          _n = _nMax;
  404.       }
  405.       return _n;
  406.    }
  407.    static function disorder(arr)
  408.    {
  409.       var _loc5_ = arr.length;
  410.       var _loc1_ = 0;
  411.       while(_loc1_ < _loc5_)
  412.       {
  413.          var _loc3_ = random(_loc5_);
  414.          var _loc4_ = arr[_loc1_];
  415.          arr[_loc1_] = arr[_loc3_];
  416.          arr[_loc3_] = _loc4_;
  417.          _loc1_ = _loc1_ + 1;
  418.       }
  419.    }
  420.    static function removeArray(_a, _ai)
  421.    {
  422.       for(var _loc2_ in _a)
  423.       {
  424.          if(_a[_loc2_] == _ai)
  425.          {
  426.             _a.splice(int(_loc2_),1);
  427.             return -1;
  428.          }
  429.       }
  430.       return _loc2_ != undefined ? 1 : 0;
  431.    }
  432.    static function forIn(_a, _s, _b, _ob)
  433.    {
  434.       var _loc2_ = [];
  435.       for(var _loc5_ in _a)
  436.       {
  437.          if((_a[_loc5_] == undefined || !_a[_loc5_][_s](_ob)) && _b)
  438.          {
  439.             _loc2_.push(_loc5_);
  440.          }
  441.       }
  442.       if(_b)
  443.       {
  444.          for(_loc5_ in _loc2_)
  445.          {
  446.             _a.splice(int(_loc2_[_loc5_]),1);
  447.          }
  448.       }
  449.    }
  450.    static function evaUndf(_ob, _ob_new)
  451.    {
  452.       if(_ob == undefined)
  453.       {
  454.          return _ob_new;
  455.       }
  456.       return _ob;
  457.    }
  458.    static function distance(x0, y0, xt, yt)
  459.    {
  460.       return Math.sqrt(Math.pow(xt - x0,2) + Math.pow(yt - y0,2));
  461.    }
  462.    static function side_min(x0, y0, xt, yt)
  463.    {
  464.       return Math.min(Math.abs(xt - x0),Math.abs(yt - y0));
  465.    }
  466.    static function side_max(x0, y0, xt, yt)
  467.    {
  468.       return Math.max(Math.abs(xt - x0),Math.abs(yt - y0));
  469.    }
  470.    static function rFloor(r)
  471.    {
  472.       if(r >= 3.141592653589793)
  473.       {
  474.          r -= 6.283185307179586;
  475.       }
  476.       if(r <= -3.141592653589793)
  477.       {
  478.          r += 6.283185307179586;
  479.       }
  480.       return r;
  481.    }
  482.    static function rFloor_n(r)
  483.    {
  484.       if(r >= 180)
  485.       {
  486.          r -= 360;
  487.       }
  488.       if(r <= -180)
  489.       {
  490.          r += 360;
  491.       }
  492.       return r;
  493.    }
  494.    static function s_b(n, a, b)
  495.    {
  496.       if(a < n && n < b)
  497.       {
  498.          return 0;
  499.       }
  500.       if(n <= a)
  501.       {
  502.          return -1;
  503.       }
  504.       return 1;
  505.    }
  506.    static function vpNum(_n, _t)
  507.    {
  508.       _t == undefined && (_t = 1);
  509.       if(_n == 0)
  510.       {
  511.          return 0;
  512.       }
  513.       if(_n > 0)
  514.       {
  515.          return _t;
  516.       }
  517.       return - _t;
  518.    }
  519.    static function formatTime(_n)
  520.    {
  521.       var _loc3_ = undefined;
  522.       var _loc4_ = undefined;
  523.       var _loc2_ = undefined;
  524.       if(_n < 60)
  525.       {
  526.          _loc4_ = _loc3_ = 0;
  527.          _loc2_ = _n;
  528.       }
  529.       else if(_n < 3600)
  530.       {
  531.          _loc3_ = 0;
  532.          _loc4_ = Math.floor(_n / 60);
  533.          _loc2_ = _n % 60;
  534.       }
  535.       else
  536.       {
  537.          _loc3_ = Math.floor(_n / 3600);
  538.          _loc4_ = Math.floor(_n / 60) % 60;
  539.          _loc2_ = _n % 60;
  540.       }
  541.       var _loc5_ = _loc3_ >= 10 ? _loc3_ : "0" + _loc3_;
  542.       var _loc7_ = _loc4_ >= 10 ? _loc4_ : "0" + _loc4_;
  543.       var _loc6_ = _loc2_ >= 10 ? _loc2_ : "0" + _loc2_;
  544.       return _loc5_ + ":" + _loc7_ + ":" + _loc6_;
  545.    }
  546.    static function unlinearCycle(x, T, r)
  547.    {
  548.       var _loc1_ = T / 2;
  549.       var _loc2_ = (- r) / (_loc1_ * _loc1_);
  550.       return _loc2_ * Math.pow(x % T - _loc1_,2) + r;
  551.    }
  552.    static function linearCycle(x, T, r)
  553.    {
  554.       var _loc1_ = T / 2;
  555.       x %= T;
  556.       if(x > _loc1_)
  557.       {
  558.          return (1 - x % _loc1_ / _loc1_) * r;
  559.       }
  560.       if(x < _loc1_)
  561.       {
  562.          return x % _loc1_ / _loc1_ * r;
  563.       }
  564.       return r;
  565.    }
  566.    static function getAngle(_m1, _m2)
  567.    {
  568.       if(_m1._parent == _m2._parent)
  569.       {
  570.          return Math.atan2(_m1._y - _m2._y,_m1._x - _m2._x);
  571.       }
  572.    }
  573.    static function parabolaSpeed(x0, y0, xt, yt, nR, nG)
  574.    {
  575.       var _loc1_ = xt - x0;
  576.       var _loc2_ = yt - y0;
  577.       return Math.sqrt(nG * _loc1_ / (Math.tan(nR) - _loc2_ / _loc1_) / Math.pow(Math.cos(nR),2) / 2);
  578.    }
  579.    static function parabolaRot(x0, y0, xt, yt, nV, nG)
  580.    {
  581.       var _loc5_ = xt - x0;
  582.       var _loc7_ = yt - y0;
  583.       var _loc2_ = nG * _loc5_ * _loc5_ / (2 * nV * nV);
  584.       var _loc1_ = _loc5_;
  585.       var _loc6_ = _loc2_ - _loc7_;
  586.       var _loc4_ = _loc1_ * _loc1_ - 4 * _loc2_ * _loc6_;
  587.       if(_loc4_ < 0)
  588.       {
  589.          return undefined;
  590.       }
  591.       var _loc3_ = new Object();
  592.       if(_loc5_ > 0)
  593.       {
  594.          _loc3_.x1 = Math.atan((- _loc1_ - Math.sqrt(_loc4_)) / (2 * _loc2_));
  595.          _loc3_.x2 = Math.atan((- _loc1_ + Math.sqrt(_loc4_)) / (2 * _loc2_));
  596.       }
  597.       else
  598.       {
  599.          _loc3_.x1 = Math.atan((- _loc1_ - Math.sqrt(_loc4_)) / (2 * _loc2_)) - 3.141592653589793;
  600.          _loc3_.x2 = Math.atan((- _loc1_ + Math.sqrt(_loc4_)) / (2 * _loc2_)) - 3.141592653589793;
  601.       }
  602.       return _loc3_;
  603.    }
  604.    static function deepObjectCopy(obj)
  605.    {
  606.       if(typeof obj != "object" || obj instanceof Button || obj instanceof TextField || obj instanceof MovieClip)
  607.       {
  608.          return obj;
  609.       }
  610.       var _loc3_ = undefined;
  611.       if(obj instanceof Boolean)
  612.       {
  613.          _loc3_ = new Boolean(Boolean.prototype.valueOf.call(obj));
  614.       }
  615.       else if(obj instanceof Number)
  616.       {
  617.          _loc3_ = new Number(Number.prototype.valueOf.call(obj));
  618.       }
  619.       else if(obj instanceof String)
  620.       {
  621.          _loc3_ = new String(String.prototype.valueOf.call(obj));
  622.       }
  623.       else if(obj.__constructor__)
  624.       {
  625.          if(typeof obj.clone == "function")
  626.          {
  627.             _loc3_ = obj.clone();
  628.             if(_loc3_.__proto__ == obj.__proto__)
  629.             {
  630.                return _loc3_;
  631.             }
  632.          }
  633.          _loc3_ = new obj.__constructor__();
  634.       }
  635.       else if(obj instanceof Array)
  636.       {
  637.          _loc3_ = [];
  638.       }
  639.       else
  640.       {
  641.          _loc3_ = {};
  642.       }
  643.       for(var _loc4_ in obj)
  644.       {
  645.          if(obj.hasOwnProperty(_loc4_))
  646.          {
  647.             _loc3_[_loc4_] = arguments.callee(obj[_loc4_]);
  648.          }
  649.       }
  650.       return _loc3_;
  651.    }
  652. }
  653.