home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / Slippery_Side_Swipe.swf / scripts / __Packages / caurina / transitions / Equations.as < prev    next >
Encoding:
Text File  |  2008-09-24  |  27.1 KB  |  654 lines
  1. function ┬º\x04\x05┬º()
  2. {
  3.    set("\x03",307 % 511 * true);
  4.    return eval("\x03");
  5. }
  6. var ┬º\x01┬º = 6 + "\x04\x05"();
  7. while(true)
  8. {
  9.    if(eval("\x01") == 313)
  10.    {
  11.       set("\x01",eval("\x01") + 259);
  12.       ┬º┬ºpush(true);
  13.    }
  14.    else if(eval("\x01") == 388)
  15.    {
  16.       set("\x01",eval("\x01") + 478);
  17.       ┬º┬ºpush("\x0f");
  18.       ┬º┬ºpush(1);
  19.    }
  20.    else if(eval("\x01") == 572)
  21.    {
  22.       set("\x01",eval("\x01") - 198);
  23.       if(function ┬º\x04\x05┬º()
  24.       {
  25.          set("\x03",307 % 511 * true);
  26.          return eval("\x03");
  27.       })
  28.       {
  29.          set("\x01",eval("\x01") + 81);
  30.       }
  31.    }
  32.    else if(eval("\x01") == 33)
  33.    {
  34.       set("\x01",eval("\x01") - 18);
  35.       ┬º┬ºpush("\x0f");
  36.    }
  37.    else if(eval("\x01") == 866)
  38.    {
  39.       set("\x01",eval("\x01") - 833);
  40.       var ┬º┬ºpop() = function ┬º\x04\x05┬º()
  41.       {
  42.          set("\x03",307 % 511 * true);
  43.          return eval("\x03");
  44.       };
  45.    }
  46.    else if(eval("\x01") == 510)
  47.    {
  48.       set("\x01",eval("\x01") + 189);
  49.    }
  50.    else
  51.    {
  52.       if(eval("\x01") == 699)
  53.       {
  54.          set("\x01",eval("\x01") - 269);
  55.          if(!_global.caurina)
  56.          {
  57.             _global.caurina = new Object();
  58.          }
  59.          function ┬º\x04\x05┬º()
  60.          {
  61.             set("\x03",307 % 511 * true);
  62.             return eval("\x03");
  63.          }
  64.          if(!_global.caurina.transitions)
  65.          {
  66.             _global.caurina.transitions = new Object();
  67.          }
  68.          ┬º┬ºpop();
  69.          if(!_global.caurina.transitions.Equations)
  70.          {
  71.             var _loc2_ = caurina.transitions.Equations = function()
  72.             {
  73.                trace("Equations is a static class and should not be instantiated.");
  74.             }.prototype;
  75.             caurina.transitions.Equations = function()
  76.             {
  77.                trace("Equations is a static class and should not be instantiated.");
  78.             }.init = function()
  79.             {
  80.                caurina.transitions.Tweener.registerTransition("easenone",caurina.transitions.Equations.easeNone);
  81.                caurina.transitions.Tweener.registerTransition("linear",caurina.transitions.Equations.easeNone);
  82.                caurina.transitions.Tweener.registerTransition("easeinquad",caurina.transitions.Equations.easeInQuad);
  83.                caurina.transitions.Tweener.registerTransition("easeoutquad",caurina.transitions.Equations.easeOutQuad);
  84.                caurina.transitions.Tweener.registerTransition("easeinoutquad",caurina.transitions.Equations.easeInOutQuad);
  85.                caurina.transitions.Tweener.registerTransition("easeoutinquad",caurina.transitions.Equations.easeOutInQuad);
  86.                caurina.transitions.Tweener.registerTransition("easeincubic",caurina.transitions.Equations.easeInCubic);
  87.                caurina.transitions.Tweener.registerTransition("easeoutcubic",caurina.transitions.Equations.easeOutCubic);
  88.                caurina.transitions.Tweener.registerTransition("easeinoutcubic",caurina.transitions.Equations.easeInOutCubic);
  89.                caurina.transitions.Tweener.registerTransition("easeoutincubic",caurina.transitions.Equations.easeOutInCubic);
  90.                caurina.transitions.Tweener.registerTransition("easeinquart",caurina.transitions.Equations.easeInQuart);
  91.                caurina.transitions.Tweener.registerTransition("easeoutquart",caurina.transitions.Equations.easeOutQuart);
  92.                caurina.transitions.Tweener.registerTransition("easeinoutquart",caurina.transitions.Equations.easeInOutQuart);
  93.                caurina.transitions.Tweener.registerTransition("easeoutinquart",caurina.transitions.Equations.easeOutInQuart);
  94.                caurina.transitions.Tweener.registerTransition("easeinquint",caurina.transitions.Equations.easeInQuint);
  95.                caurina.transitions.Tweener.registerTransition("easeoutquint",caurina.transitions.Equations.easeOutQuint);
  96.                caurina.transitions.Tweener.registerTransition("easeinoutquint",caurina.transitions.Equations.easeInOutQuint);
  97.                caurina.transitions.Tweener.registerTransition("easeoutinquint",caurina.transitions.Equations.easeOutInQuint);
  98.                caurina.transitions.Tweener.registerTransition("easeinsine",caurina.transitions.Equations.easeInSine);
  99.                caurina.transitions.Tweener.registerTransition("easeoutsine",caurina.transitions.Equations.easeOutSine);
  100.                caurina.transitions.Tweener.registerTransition("easeinoutsine",caurina.transitions.Equations.easeInOutSine);
  101.                caurina.transitions.Tweener.registerTransition("easeoutinsine",caurina.transitions.Equations.easeOutInSine);
  102.                caurina.transitions.Tweener.registerTransition("easeincirc",caurina.transitions.Equations.easeInCirc);
  103.                caurina.transitions.Tweener.registerTransition("easeoutcirc",caurina.transitions.Equations.easeOutCirc);
  104.                caurina.transitions.Tweener.registerTransition("easeinoutcirc",caurina.transitions.Equations.easeInOutCirc);
  105.                caurina.transitions.Tweener.registerTransition("easeoutincirc",caurina.transitions.Equations.easeOutInCirc);
  106.                caurina.transitions.Tweener.registerTransition("easeinexpo",caurina.transitions.Equations.easeInExpo);
  107.                caurina.transitions.Tweener.registerTransition("easeoutexpo",caurina.transitions.Equations.easeOutExpo);
  108.                caurina.transitions.Tweener.registerTransition("easeinoutexpo",caurina.transitions.Equations.easeInOutExpo);
  109.                caurina.transitions.Tweener.registerTransition("easeoutinexpo",caurina.transitions.Equations.easeOutInExpo);
  110.                caurina.transitions.Tweener.registerTransition("easeinelastic",caurina.transitions.Equations.easeInElastic);
  111.                caurina.transitions.Tweener.registerTransition("easeoutelastic",caurina.transitions.Equations.easeOutElastic);
  112.                caurina.transitions.Tweener.registerTransition("easeinoutelastic",caurina.transitions.Equations.easeInOutElastic);
  113.                caurina.transitions.Tweener.registerTransition("easeoutinelastic",caurina.transitions.Equations.easeOutInElastic);
  114.                caurina.transitions.Tweener.registerTransition("easeinback",caurina.transitions.Equations.easeInBack);
  115.                caurina.transitions.Tweener.registerTransition("easeoutback",caurina.transitions.Equations.easeOutBack);
  116.                caurina.transitions.Tweener.registerTransition("easeinoutback",caurina.transitions.Equations.easeInOutBack);
  117.                caurina.transitions.Tweener.registerTransition("easeoutinback",caurina.transitions.Equations.easeOutInBack);
  118.                caurina.transitions.Tweener.registerTransition("easeinbounce",caurina.transitions.Equations.easeInBounce);
  119.                caurina.transitions.Tweener.registerTransition("easeoutbounce",caurina.transitions.Equations.easeOutBounce);
  120.                caurina.transitions.Tweener.registerTransition("easeinoutbounce",caurina.transitions.Equations.easeInOutBounce);
  121.                caurina.transitions.Tweener.registerTransition("easeoutinbounce",caurina.transitions.Equations.easeOutInBounce);
  122.             };
  123.             caurina.transitions.Equations = function()
  124.             {
  125.                trace("Equations is a static class and should not be instantiated.");
  126.             }.easeNone = function(t, b, c, d)
  127.             {
  128.                return c * t / d + b;
  129.             };
  130.             caurina.transitions.Equations = function()
  131.             {
  132.                trace("Equations is a static class and should not be instantiated.");
  133.             }.easeInQuad = function(t, b, c, d)
  134.             {
  135.                return c * (t /= d) * t + b;
  136.             };
  137.             caurina.transitions.Equations = function()
  138.             {
  139.                trace("Equations is a static class and should not be instantiated.");
  140.             }.easeOutQuad = function(t, b, c, d)
  141.             {
  142.                return (- c) * (t /= d) * (t - 2) + b;
  143.             };
  144.             caurina.transitions.Equations = function()
  145.             {
  146.                trace("Equations is a static class and should not be instantiated.");
  147.             }.easeInOutQuad = function(t, b, c, d)
  148.             {
  149.                if((t /= d / 2) < 1)
  150.                {
  151.                   return c / 2 * t * t + b;
  152.                }
  153.                return (- c) / 2 * ((t = t - 1) * (t - 2) - 1) + b;
  154.             };
  155.             caurina.transitions.Equations = function()
  156.             {
  157.                trace("Equations is a static class and should not be instantiated.");
  158.             }.easeOutInQuad = function(t, b, c, d)
  159.             {
  160.                if(t < d / 2)
  161.                {
  162.                   return caurina.transitions.Equations.easeOutQuad(t * 2,b,c / 2,d);
  163.                }
  164.                return caurina.transitions.Equations.easeInQuad(t * 2 - d,b + c / 2,c / 2,d);
  165.             };
  166.             caurina.transitions.Equations = function()
  167.             {
  168.                trace("Equations is a static class and should not be instantiated.");
  169.             }.easeInCubic = function(t, b, c, d)
  170.             {
  171.                return c * (t /= d) * t * t + b;
  172.             };
  173.             caurina.transitions.Equations = function()
  174.             {
  175.                trace("Equations is a static class and should not be instantiated.");
  176.             }.easeOutCubic = function(t, b, c, d)
  177.             {
  178.                return c * ((t = t / d - 1) * t * t + 1) + b;
  179.             };
  180.             caurina.transitions.Equations = function()
  181.             {
  182.                trace("Equations is a static class and should not be instantiated.");
  183.             }.easeInOutCubic = function(t, b, c, d)
  184.             {
  185.                if((t /= d / 2) < 1)
  186.                {
  187.                   return c / 2 * t * t * t + b;
  188.                }
  189.                return c / 2 * ((t -= 2) * t * t + 2) + b;
  190.             };
  191.             caurina.transitions.Equations = function()
  192.             {
  193.                trace("Equations is a static class and should not be instantiated.");
  194.             }.easeOutInCubic = function(t, b, c, d)
  195.             {
  196.                if(t < d / 2)
  197.                {
  198.                   return caurina.transitions.Equations.easeOutCubic(t * 2,b,c / 2,d);
  199.                }
  200.                return caurina.transitions.Equations.easeInCubic(t * 2 - d,b + c / 2,c / 2,d);
  201.             };
  202.             caurina.transitions.Equations = function()
  203.             {
  204.                trace("Equations is a static class and should not be instantiated.");
  205.             }.easeInQuart = function(t, b, c, d)
  206.             {
  207.                return c * (t /= d) * t * t * t + b;
  208.             };
  209.             caurina.transitions.Equations = function()
  210.             {
  211.                trace("Equations is a static class and should not be instantiated.");
  212.             }.easeOutQuart = function(t, b, c, d)
  213.             {
  214.                return (- c) * ((t = t / d - 1) * t * t * t - 1) + b;
  215.             };
  216.             caurina.transitions.Equations = function()
  217.             {
  218.                trace("Equations is a static class and should not be instantiated.");
  219.             }.easeInOutQuart = function(t, b, c, d)
  220.             {
  221.                if((t /= d / 2) < 1)
  222.                {
  223.                   return c / 2 * t * t * t * t + b;
  224.                }
  225.                return (- c) / 2 * ((t -= 2) * t * t * t - 2) + b;
  226.             };
  227.             caurina.transitions.Equations = function()
  228.             {
  229.                trace("Equations is a static class and should not be instantiated.");
  230.             }.easeOutInQuart = function(t, b, c, d)
  231.             {
  232.                if(t < d / 2)
  233.                {
  234.                   return caurina.transitions.Equations.easeOutQuart(t * 2,b,c / 2,d);
  235.                }
  236.                return caurina.transitions.Equations.easeInQuart(t * 2 - d,b + c / 2,c / 2,d);
  237.             };
  238.             caurina.transitions.Equations = function()
  239.             {
  240.                trace("Equations is a static class and should not be instantiated.");
  241.             }.easeInQuint = function(t, b, c, d)
  242.             {
  243.                return c * (t /= d) * t * t * t * t + b;
  244.             };
  245.             caurina.transitions.Equations = function()
  246.             {
  247.                trace("Equations is a static class and should not be instantiated.");
  248.             }.easeOutQuint = function(t, b, c, d)
  249.             {
  250.                return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
  251.             };
  252.             caurina.transitions.Equations = function()
  253.             {
  254.                trace("Equations is a static class and should not be instantiated.");
  255.             }.easeInOutQuint = function(t, b, c, d)
  256.             {
  257.                if((t /= d / 2) < 1)
  258.                {
  259.                   return c / 2 * t * t * t * t * t + b;
  260.                }
  261.                return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
  262.             };
  263.             caurina.transitions.Equations = function()
  264.             {
  265.                trace("Equations is a static class and should not be instantiated.");
  266.             }.easeOutInQuint = function(t, b, c, d)
  267.             {
  268.                if(t < d / 2)
  269.                {
  270.                   return caurina.transitions.Equations.easeOutQuint(t * 2,b,c / 2,d);
  271.                }
  272.                return caurina.transitions.Equations.easeInQuint(t * 2 - d,b + c / 2,c / 2,d);
  273.             };
  274.             caurina.transitions.Equations = function()
  275.             {
  276.                trace("Equations is a static class and should not be instantiated.");
  277.             }.easeInSine = function(t, b, c, d)
  278.             {
  279.                return (- c) * Math.cos(t / d * 1.5707963267948966) + c + b;
  280.             };
  281.             caurina.transitions.Equations = function()
  282.             {
  283.                trace("Equations is a static class and should not be instantiated.");
  284.             }.easeOutSine = function(t, b, c, d)
  285.             {
  286.                return c * Math.sin(t / d * 1.5707963267948966) + b;
  287.             };
  288.             caurina.transitions.Equations = function()
  289.             {
  290.                trace("Equations is a static class and should not be instantiated.");
  291.             }.easeInOutSine = function(t, b, c, d)
  292.             {
  293.                return (- c) / 2 * (Math.cos(3.141592653589793 * t / d) - 1) + b;
  294.             };
  295.             caurina.transitions.Equations = function()
  296.             {
  297.                trace("Equations is a static class and should not be instantiated.");
  298.             }.easeOutInSine = function(t, b, c, d)
  299.             {
  300.                if(t < d / 2)
  301.                {
  302.                   return caurina.transitions.Equations.easeOutSine(t * 2,b,c / 2,d);
  303.                }
  304.                return caurina.transitions.Equations.easeInSine(t * 2 - d,b + c / 2,c / 2,d);
  305.             };
  306.             caurina.transitions.Equations = function()
  307.             {
  308.                trace("Equations is a static class and should not be instantiated.");
  309.             }.easeInExpo = function(t, b, c, d)
  310.             {
  311.                return t != 0 ? c * Math.pow(2,10 * (t / d - 1)) + b : b;
  312.             };
  313.             caurina.transitions.Equations = function()
  314.             {
  315.                trace("Equations is a static class and should not be instantiated.");
  316.             }.easeOutExpo = function(t, b, c, d)
  317.             {
  318.                return t != d ? c * (- Math.pow(2,-10 * t / d) + 1) + b : b + c;
  319.             };
  320.             caurina.transitions.Equations = function()
  321.             {
  322.                trace("Equations is a static class and should not be instantiated.");
  323.             }.easeInOutExpo = function(t, b, c, d)
  324.             {
  325.                if(t == 0)
  326.                {
  327.                   return b;
  328.                }
  329.                if(t == d)
  330.                {
  331.                   return b + c;
  332.                }
  333.                if((t /= d / 2) < 1)
  334.                {
  335.                   return c / 2 * Math.pow(2,10 * (t - 1)) + b;
  336.                }
  337.                return c / 2 * (- Math.pow(2,-10 * (t = t - 1)) + 2) + b;
  338.             };
  339.             caurina.transitions.Equations = function()
  340.             {
  341.                trace("Equations is a static class and should not be instantiated.");
  342.             }.easeOutInExpo = function(t, b, c, d)
  343.             {
  344.                if(t < d / 2)
  345.                {
  346.                   return caurina.transitions.Equations.easeOutExpo(t * 2,b,c / 2,d);
  347.                }
  348.                return caurina.transitions.Equations.easeInExpo(t * 2 - d,b + c / 2,c / 2,d);
  349.             };
  350.             caurina.transitions.Equations = function()
  351.             {
  352.                trace("Equations is a static class and should not be instantiated.");
  353.             }.easeInCirc = function(t, b, c, d)
  354.             {
  355.                return (- c) * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
  356.             };
  357.             caurina.transitions.Equations = function()
  358.             {
  359.                trace("Equations is a static class and should not be instantiated.");
  360.             }.easeOutCirc = function(t, b, c, d)
  361.             {
  362.                return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
  363.             };
  364.             caurina.transitions.Equations = function()
  365.             {
  366.                trace("Equations is a static class and should not be instantiated.");
  367.             }.easeInOutCirc = function(t, b, c, d)
  368.             {
  369.                if((t /= d / 2) < 1)
  370.                {
  371.                   return (- c) / 2 * (Math.sqrt(1 - t * t) - 1) + b;
  372.                }
  373.                return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
  374.             };
  375.             caurina.transitions.Equations = function()
  376.             {
  377.                trace("Equations is a static class and should not be instantiated.");
  378.             }.easeOutInCirc = function(t, b, c, d)
  379.             {
  380.                if(t < d / 2)
  381.                {
  382.                   return caurina.transitions.Equations.easeOutCirc(t * 2,b,c / 2,d);
  383.                }
  384.                return caurina.transitions.Equations.easeInCirc(t * 2 - d,b + c / 2,c / 2,d);
  385.             };
  386.             caurina.transitions.Equations = function()
  387.             {
  388.                trace("Equations is a static class and should not be instantiated.");
  389.             }.easeInElastic = function(t, b, c, d, a, p)
  390.             {
  391.                var _loc5_ = undefined;
  392.                if(t == 0)
  393.                {
  394.                   return b;
  395.                }
  396.                if((t /= d) == 1)
  397.                {
  398.                   return b + c;
  399.                }
  400.                if(!p)
  401.                {
  402.                   p = d * 0.3;
  403.                }
  404.                if(!a || a < Math.abs(c))
  405.                {
  406.                   a = c;
  407.                   _loc5_ = p / 4;
  408.                }
  409.                else
  410.                {
  411.                   _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  412.                }
  413.                return - a * Math.pow(2,10 * (t -= 1)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p) + b;
  414.             };
  415.             caurina.transitions.Equations = function()
  416.             {
  417.                trace("Equations is a static class and should not be instantiated.");
  418.             }.easeOutElastic = function(t, b, c, d, a, p)
  419.             {
  420.                var _loc5_ = undefined;
  421.                if(t == 0)
  422.                {
  423.                   return b;
  424.                }
  425.                if((t /= d) == 1)
  426.                {
  427.                   return b + c;
  428.                }
  429.                if(!p)
  430.                {
  431.                   p = d * 0.3;
  432.                }
  433.                if(!a || a < Math.abs(c))
  434.                {
  435.                   a = c;
  436.                   _loc5_ = p / 4;
  437.                }
  438.                else
  439.                {
  440.                   _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  441.                }
  442.                return a * Math.pow(2,-10 * t) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p) + c + b;
  443.             };
  444.             caurina.transitions.Equations = function()
  445.             {
  446.                trace("Equations is a static class and should not be instantiated.");
  447.             }.easeInOutElastic = function(t, b, c, d, a, p)
  448.             {
  449.                var _loc5_ = undefined;
  450.                if(t == 0)
  451.                {
  452.                   return b;
  453.                }
  454.                if((t /= d / 2) == 2)
  455.                {
  456.                   return b + c;
  457.                }
  458.                if(!p)
  459.                {
  460.                   p = d * 0.44999999999999996;
  461.                }
  462.                if(!a || a < Math.abs(c))
  463.                {
  464.                   a = c;
  465.                   _loc5_ = p / 4;
  466.                }
  467.                else
  468.                {
  469.                   _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  470.                }
  471.                if(t < 1)
  472.                {
  473.                   return -0.5 * (a * Math.pow(2,10 * (t -= 1)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p)) + b;
  474.                }
  475.                return a * Math.pow(2,-10 * (t -= 1)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p) * 0.5 + c + b;
  476.             };
  477.             caurina.transitions.Equations = function()
  478.             {
  479.                trace("Equations is a static class and should not be instantiated.");
  480.             }.easeOutInElastic = function(t, b, c, d, a, p)
  481.             {
  482.                if(t < d / 2)
  483.                {
  484.                   return caurina.transitions.Equations.easeOutElastic(t * 2,b,c / 2,d,a,p);
  485.                }
  486.                return caurina.transitions.Equations.easeInElastic(t * 2 - d,b + c / 2,c / 2,d,a,p);
  487.             };
  488.             caurina.transitions.Equations = function()
  489.             {
  490.                trace("Equations is a static class and should not be instantiated.");
  491.             }.easeInBack = function(t, b, c, d, s)
  492.             {
  493.                if(s == undefined)
  494.                {
  495.                   s = 1.70158;
  496.                }
  497.                return c * (t /= d) * t * ((s + 1) * t - s) + b;
  498.             };
  499.             caurina.transitions.Equations = function()
  500.             {
  501.                trace("Equations is a static class and should not be instantiated.");
  502.             }.easeOutBack = function(t, b, c, d, s)
  503.             {
  504.                if(s == undefined)
  505.                {
  506.                   s = 1.70158;
  507.                }
  508.                return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
  509.             };
  510.             caurina.transitions.Equations = function()
  511.             {
  512.                trace("Equations is a static class and should not be instantiated.");
  513.             }.easeInOutBack = function(t, b, c, d, s)
  514.             {
  515.                if(s == undefined)
  516.                {
  517.                   s = 1.70158;
  518.                }
  519.                if((t /= d / 2) < 1)
  520.                {
  521.                   return c / 2 * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
  522.                }
  523.                return c / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;
  524.             };
  525.             caurina.transitions.Equations = function()
  526.             {
  527.                trace("Equations is a static class and should not be instantiated.");
  528.             }.easeOutInBack = function(t, b, c, d, s)
  529.             {
  530.                if(t < d / 2)
  531.                {
  532.                   return caurina.transitions.Equations.easeOutBack(t * 2,b,c / 2,d,s);
  533.                }
  534.                return caurina.transitions.Equations.easeInBack(t * 2 - d,b + c / 2,c / 2,d,s);
  535.             };
  536.             caurina.transitions.Equations = function()
  537.             {
  538.                trace("Equations is a static class and should not be instantiated.");
  539.             }.easeInBounce = function(t, b, c, d)
  540.             {
  541.                return c - caurina.transitions.Equations.easeOutBounce(d - t,0,c,d) + b;
  542.             };
  543.             caurina.transitions.Equations = function()
  544.             {
  545.                trace("Equations is a static class and should not be instantiated.");
  546.             }.easeOutBounce = function(t, b, c, d)
  547.             {
  548.                if((t /= d) < 0.36363636363636365)
  549.                {
  550.                   return c * (7.5625 * t * t) + b;
  551.                }
  552.                if(t < 0.7272727272727273)
  553.                {
  554.                   return c * (7.5625 * (t -= 0.5454545454545454) * t + 0.75) + b;
  555.                }
  556.                if(t < 0.9090909090909091)
  557.                {
  558.                   return c * (7.5625 * (t -= 0.8181818181818182) * t + 0.9375) + b;
  559.                }
  560.                return c * (7.5625 * (t -= 0.9545454545454546) * t + 0.984375) + b;
  561.             };
  562.             caurina.transitions.Equations = function()
  563.             {
  564.                trace("Equations is a static class and should not be instantiated.");
  565.             }.easeInOutBounce = function(t, b, c, d)
  566.             {
  567.                if(t < d / 2)
  568.                {
  569.                   return caurina.transitions.Equations.easeInBounce(t * 2,0,c,d) * 0.5 + b;
  570.                }
  571.                return caurina.transitions.Equations.easeOutBounce(t * 2 - d,0,c,d) * 0.5 + c * 0.5 + b;
  572.             };
  573.             caurina.transitions.Equations = function()
  574.             {
  575.                trace("Equations is a static class and should not be instantiated.");
  576.             }.easeOutInBounce = function(t, b, c, d)
  577.             {
  578.                if(t < d / 2)
  579.                {
  580.                   return caurina.transitions.Equations.easeOutBounce(t * 2,b,c / 2,d);
  581.                }
  582.                return caurina.transitions.Equations.easeInBounce(t * 2 - d,b + c / 2,c / 2,d);
  583.             };
  584.             ┬º┬ºpush(ASSetPropFlags(caurina.transitions.Equations.prototype,null,1));
  585.          }
  586.          ┬º┬ºpop();
  587.          break;
  588.       }
  589.       if(eval("\x01") == 455)
  590.       {
  591.          set("\x01",eval("\x01") - 67);
  592.       }
  593.       else
  594.       {
  595.          if(eval("\x01") == 374)
  596.          {
  597.             set("\x01",eval("\x01") + 81);
  598.             toggleHighQuality();
  599.             return ┬º┬ºpop()[function ┬º\x04\x05┬º()
  600.             {
  601.                set("\x03",307 % 511 * true);
  602.                return eval("\x03");
  603.             }] - 1;
  604.          }
  605.          if(eval("\x01") == 244)
  606.          {
  607.             set("\x01",eval("\x01") + 144);
  608.          }
  609.          else if(eval("\x01") == 15)
  610.          {
  611.             set("\x01",eval("\x01") + 186);
  612.             ┬º┬ºpush(eval(function ┬º\x04\x05┬º()
  613.             {
  614.                set("\x03",307 % 511 * true);
  615.                return eval("\x03");
  616.             }));
  617.          }
  618.          else
  619.          {
  620.             if(eval("\x01") == 430)
  621.             {
  622.                set("\x01",eval("\x01") - 430);
  623.                break;
  624.             }
  625.             if(eval("\x01") == 201)
  626.             {
  627.                set("\x01",eval("\x01") + 199);
  628.                ┬º┬ºpush(!function ┬º\x04\x05┬º()
  629.                {
  630.                   set("\x03",307 % 511 * true);
  631.                   return eval("\x03");
  632.                });
  633.             }
  634.             else
  635.             {
  636.                if(eval("\x01") != 400)
  637.                {
  638.                   break;
  639.                }
  640.                set("\x01",eval("\x01") + 110);
  641.                if(function ┬º\x04\x05┬º()
  642.                {
  643.                   set("\x03",307 % 511 * true);
  644.                   return eval("\x03");
  645.                })
  646.                {
  647.                   set("\x01",eval("\x01") + 189);
  648.                }
  649.             }
  650.          }
  651.       }
  652.    }
  653. }
  654.