home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / bashing-pumpkins.swf / scripts / frame_25 / DoAction.as
Encoding:
Text File  |  2007-12-12  |  67.0 KB  |  1,250 lines

  1. var ┬º\x01┬º = 252;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 252)
  6.    {
  7.       set("\x01",eval("\x01") + 78);
  8.       ┬º┬ºpush(true);
  9.    }
  10.    else if(eval("\x01") == 214)
  11.    {
  12.       set("\x01",eval("\x01") + 741);
  13.       if(┬º┬ºpop())
  14.       {
  15.          set("\x01",eval("\x01") - 865);
  16.       }
  17.    }
  18.    else
  19.    {
  20.       if(eval("\x01") == 105)
  21.       {
  22.          set("\x01",eval("\x01") + 291);
  23.          break;
  24.       }
  25.       if(eval("\x01") == 532)
  26.       {
  27.          set("\x01",eval("\x01") - 165);
  28.          ┬º┬ºpush(true);
  29.       }
  30.       else
  31.       {
  32.          if(eval("\x01") == 157)
  33.          {
  34.             set("\x01",eval("\x01") + 690);
  35.             break;
  36.          }
  37.          if(eval("\x01") == 572)
  38.          {
  39.             set("\x01",eval("\x01") + 422);
  40.             if(┬º┬ºpop())
  41.             {
  42.                set("\x01",eval("\x01") - 768);
  43.             }
  44.          }
  45.          else if(eval("\x01") == 365)
  46.          {
  47.             set("\x01",eval("\x01") + 440);
  48.             ┬º┬ºpush(true);
  49.          }
  50.          else if(eval("\x01") == 923)
  51.          {
  52.             set("\x01",eval("\x01") - 351);
  53.             ┬º┬ºpush(true);
  54.          }
  55.          else if(eval("\x01") == 648)
  56.          {
  57.             set("\x01",eval("\x01") + 112);
  58.             if(┬º┬ºpop())
  59.             {
  60.                set("\x01",eval("\x01") + 32);
  61.             }
  62.          }
  63.          else if(eval("\x01") == 575)
  64.          {
  65.             set("\x01",eval("\x01") - 418);
  66.             if(┬º┬ºpop())
  67.             {
  68.                set("\x01",eval("\x01") + 690);
  69.             }
  70.          }
  71.          else if(eval("\x01") == 396)
  72.          {
  73.             set("\x01",eval("\x01") - 153);
  74.             ┬º┬ºpush(true);
  75.          }
  76.          else
  77.          {
  78.             if(eval("\x01") != 243)
  79.             {
  80.                if(eval("\x01") == 617)
  81.                {
  82.                   set("\x01",eval("\x01") + 282);
  83.                   loop3:
  84.                   while(true)
  85.                   {
  86.                      set(┬º┬ºpop(),eval("\x01") - 14);
  87.                      ┬º┬ºpush(true);
  88.                      while(true)
  89.                      {
  90.                         if(eval("\x01") == 303)
  91.                         {
  92.                            set("\x01",eval("\x01") + 463);
  93.                            ┬º┬ºpush(true);
  94.                            continue;
  95.                         }
  96.                         if(eval("\x01") == 955)
  97.                         {
  98.                            set("\x01",eval("\x01") - 35);
  99.                            ┬º┬ºpush(targetPath(┬º┬ºpop() - 1));
  100.                            break loop0;
  101.                         }
  102.                         if(eval("\x01") == 278)
  103.                         {
  104.                            set("\x01",eval("\x01") + 604);
  105.                            if(┬º┬ºpop())
  106.                            {
  107.                               set("\x01",eval("\x01") - 650);
  108.                            }
  109.                            continue;
  110.                         }
  111.                         if(eval("\x01") == 212)
  112.                         {
  113.                            set("\x01",eval("\x01") + 743);
  114.                            if(┬º┬ºpop())
  115.                            {
  116.                               set("\x01",eval("\x01") - 35);
  117.                            }
  118.                            continue;
  119.                         }
  120.                         if(eval("\x01") == 141)
  121.                         {
  122.                            break loop3;
  123.                         }
  124.                         if(eval("\x01") == 889)
  125.                         {
  126.                            set("\x01",eval("\x01") - 677);
  127.                            ┬º┬ºpush(true);
  128.                            continue;
  129.                         }
  130.                         if(eval("\x01") == 850)
  131.                         {
  132.                            set("\x01",eval("\x01") + 39);
  133.                            break loop0;
  134.                         }
  135.                         if(eval("\x01") == 103)
  136.                         {
  137.                            set("\x01",eval("\x01") + 431);
  138.                            if(┬º┬ºpop())
  139.                            {
  140.                               set("\x01",eval("\x01") + 463);
  141.                            }
  142.                            continue;
  143.                         }
  144.                         if(eval("\x01") == 920)
  145.                         {
  146.                            set("\x01",eval("\x01") - 517);
  147.                            ┬º┬ºpush(true);
  148.                            continue;
  149.                         }
  150.                         if(eval("\x01") == 333)
  151.                         {
  152.                            set("\x01",eval("\x01") + 617);
  153.                            break loop0;
  154.                         }
  155.                         if(eval("\x01") == 668)
  156.                         {
  157.                            set("\x01",eval("\x01") - 390);
  158.                            ┬º┬ºpush(true);
  159.                            continue;
  160.                         }
  161.                         if(eval("\x01") == 950)
  162.                         {
  163.                            set("\x01",eval("\x01") - 847);
  164.                            ┬º┬ºpush(true);
  165.                            continue;
  166.                         }
  167.                         if(eval("\x01") == 534)
  168.                         {
  169.                            break;
  170.                         }
  171.                         if(eval("\x01") == 766)
  172.                         {
  173.                            set("\x01",eval("\x01") + 84);
  174.                            if(┬º┬ºpop())
  175.                            {
  176.                               set("\x01",eval("\x01") + 39);
  177.                            }
  178.                            continue;
  179.                         }
  180.                         if(eval("\x01") == 983)
  181.                         {
  182.                            set("\x01",eval("\x01") - 842);
  183.                            if(┬º┬ºpop())
  184.                            {
  185.                               set("\x01",eval("\x01") + 527);
  186.                            }
  187.                            continue;
  188.                         }
  189.                         if(eval("\x01") == 997)
  190.                         {
  191.                            continue loop3;
  192.                         }
  193.                         if(eval("\x01") == 403)
  194.                         {
  195.                            set("\x01",eval("\x01") - 70);
  196.                            if(┬º┬ºpop())
  197.                            {
  198.                               set("\x01",eval("\x01") + 617);
  199.                            }
  200.                            continue;
  201.                         }
  202.                         if(eval("\x01") != 882)
  203.                         {
  204.                            if(eval("\x01") == 232)
  205.                            {
  206.                               set("\x01",eval("\x01") + 611);
  207.                               Sounds.buttonClick();
  208.                               Shell.closeRules();
  209.                            }
  210.                            break loop0;
  211.                         }
  212.                         set("\x01",eval("\x01") - 650);
  213.                         ┬º┬ºpush(┬º┬ºpop() / (┬º┬ºpop() and ┬º┬ºpop()));
  214.                         while(true)
  215.                         {
  216.                            if(eval("\x01") == 381)
  217.                            {
  218.                               set("\x01",eval("\x01") - 331);
  219.                               if(┬º┬ºpop())
  220.                               {
  221.                                  set("\x01",eval("\x01") + 778);
  222.                               }
  223.                               continue;
  224.                            }
  225.                            if(eval("\x01") == 79)
  226.                            {
  227.                               set("\x01",eval("\x01") + 427);
  228.                               break loop0;
  229.                            }
  230.                            if(eval("\x01") == 50)
  231.                            {
  232.                               set("\x01",eval("\x01") + 778);
  233.                               break loop0;
  234.                            }
  235.                            if(eval("\x01") == 828)
  236.                            {
  237.                               set("\x01",eval("\x01") - 616);
  238.                               ┬º┬ºpush(true);
  239.                               continue;
  240.                            }
  241.                            if(eval("\x01") != 496)
  242.                            {
  243.                               if(eval("\x01") == 522)
  244.                               {
  245.                                  set("\x01",eval("\x01") + 425);
  246.                                  if(┬º┬ºpop())
  247.                                  {
  248.                                     set("\x01",eval("\x01") - 696);
  249.                                  }
  250.                               }
  251.                               else if(eval("\x01") == 212)
  252.                               {
  253.                                  set("\x01",eval("\x01") + 284);
  254.                                  if(┬º┬ºpop())
  255.                                  {
  256.                                     set("\x01",eval("\x01") + 8);
  257.                                  }
  258.                               }
  259.                               else if(eval("\x01") == 660)
  260.                               {
  261.                                  set("\x01",eval("\x01") + 108);
  262.                                  ┬º┬ºpush(true);
  263.                               }
  264.                               else if(eval("\x01") == 504)
  265.                               {
  266.                                  set("\x01",eval("\x01") + 18);
  267.                                  ┬º┬ºpush(true);
  268.                               }
  269.                               else if(eval("\x01") == 693)
  270.                               {
  271.                                  set("\x01",eval("\x01") - 630);
  272.                                  if(┬º┬ºpop())
  273.                                  {
  274.                                     set("\x01",eval("\x01") + 597);
  275.                                  }
  276.                               }
  277.                               else if(eval("\x01") == 422)
  278.                               {
  279.                                  set("\x01",eval("\x01") + 463);
  280.                                  ┬º┬ºpush(true);
  281.                               }
  282.                               else if(eval("\x01") == 336)
  283.                               {
  284.                                  set("\x01",eval("\x01") + 45);
  285.                                  ┬º┬ºpush(true);
  286.                               }
  287.                               else
  288.                               {
  289.                                  if(eval("\x01") == 63)
  290.                                  {
  291.                                     set("\x01",eval("\x01") + 597);
  292.                                     break loop0;
  293.                                  }
  294.                                  if(eval("\x01") == 273)
  295.                                  {
  296.                                     set("\x01",eval("\x01") + 63);
  297.                                     if(!┬º┬ºpop())
  298.                                     {
  299.                                        set("\x01",eval("\x01") + 55);
  300.                                        stop();
  301.                                     }
  302.                                     break loop0;
  303.                                  }
  304.                                  if(eval("\x01") == 984)
  305.                                  {
  306.                                     set("\x01",eval("\x01") - 291);
  307.                                     ┬º┬ºpush(true);
  308.                                  }
  309.                                  else
  310.                                  {
  311.                                     if(eval("\x01") == 384)
  312.                                     {
  313.                                        set("\x01",eval("\x01") + 38);
  314.                                        break loop0;
  315.                                     }
  316.                                     if(eval("\x01") == 947)
  317.                                     {
  318.                                        set("\x01",eval("\x01") - 696);
  319.                                        break loop0;
  320.                                     }
  321.                                     if(eval("\x01") == 751)
  322.                                     {
  323.                                        set("\x01",eval("\x01") - 367);
  324.                                        if(┬º┬ºpop())
  325.                                        {
  326.                                           set("\x01",eval("\x01") + 38);
  327.                                        }
  328.                                     }
  329.                                     else if(eval("\x01") == 251)
  330.                                     {
  331.                                        set("\x01",eval("\x01") + 211);
  332.                                        ┬º┬ºpush(true);
  333.                                     }
  334.                                     else if(eval("\x01") == 175)
  335.                                     {
  336.                                        set("\x01",eval("\x01") + 576);
  337.                                        ┬º┬ºpush(true);
  338.                                     }
  339.                                     else if(eval("\x01") == 462)
  340.                                     {
  341.                                        set("\x01",eval("\x01") - 301);
  342.                                        if(┬º┬ºpop())
  343.                                        {
  344.                                           set("\x01",eval("\x01") + 823);
  345.                                        }
  346.                                     }
  347.                                     else
  348.                                     {
  349.                                        if(eval("\x01") == 178)
  350.                                        {
  351.                                           set("\x01",eval("\x01") - 3);
  352.                                           loop7:
  353.                                           while(true)
  354.                                           {
  355.                                              set(┬º┬ºpop(),┬º┬ºpop());
  356.                                              ┬º┬ºpush(true);
  357.                                              while(true)
  358.                                              {
  359.                                                 if(eval("\x01") == 912)
  360.                                                 {
  361.                                                    set("\x01",eval("\x01") - 910);
  362.                                                    ┬º┬ºpush(true);
  363.                                                    continue;
  364.                                                 }
  365.                                                 if(eval("\x01") == 804)
  366.                                                 {
  367.                                                    set("\x01",eval("\x01") - 196);
  368.                                                    ┬º┬ºpush(true);
  369.                                                    continue;
  370.                                                 }
  371.                                                 if(eval("\x01") == 148)
  372.                                                 {
  373.                                                    set("\x01",eval("\x01") + 798);
  374.                                                    break loop0;
  375.                                                 }
  376.                                                 if(eval("\x01") == 938)
  377.                                                 {
  378.                                                    set("\x01",eval("\x01") - 416);
  379.                                                    break loop0;
  380.                                                 }
  381.                                                 if(eval("\x01") != 171)
  382.                                                 {
  383.                                                    if(eval("\x01") == 687)
  384.                                                    {
  385.                                                       set("\x01",eval("\x01") - 285);
  386.                                                       ┬º┬ºpush(true);
  387.                                                    }
  388.                                                    else
  389.                                                    {
  390.                                                       if(eval("\x01") == 710)
  391.                                                       {
  392.                                                          set("\x01",eval("\x01") + 275);
  393.                                                          break loop0;
  394.                                                       }
  395.                                                       if(eval("\x01") == 366)
  396.                                                       {
  397.                                                          set("\x01",eval("\x01") + 321);
  398.                                                          break loop0;
  399.                                                       }
  400.                                                       if(eval("\x01") == 344)
  401.                                                       {
  402.                                                          set("\x01",eval("\x01") - 209);
  403.                                                          break loop0;
  404.                                                       }
  405.                                                       if(eval("\x01") == 135)
  406.                                                       {
  407.                                                          set("\x01",eval("\x01") + 89);
  408.                                                          ┬º┬ºpush(true);
  409.                                                       }
  410.                                                       else if(eval("\x01") == 608)
  411.                                                       {
  412.                                                          set("\x01",eval("\x01") + 265);
  413.                                                          if(┬º┬ºpop())
  414.                                                          {
  415.                                                             set("\x01",eval("\x01") + 62);
  416.                                                          }
  417.                                                       }
  418.                                                       else
  419.                                                       {
  420.                                                          if(eval("\x01") == 680)
  421.                                                          {
  422.                                                             set("\x01",eval("\x01") - 174);
  423.                                                             break loop0;
  424.                                                          }
  425.                                                          if(eval("\x01") == 522)
  426.                                                          {
  427.                                                             set("\x01",eval("\x01") + 177);
  428.                                                             ┬º┬ºpush(true);
  429.                                                          }
  430.                                                          else if(eval("\x01") == 755)
  431.                                                          {
  432.                                                             set("\x01",eval("\x01") - 411);
  433.                                                             if(┬º┬ºpop())
  434.                                                             {
  435.                                                                set("\x01",eval("\x01") - 209);
  436.                                                             }
  437.                                                          }
  438.                                                          else
  439.                                                          {
  440.                                                             if(eval("\x01") == 985)
  441.                                                             {
  442.                                                                break;
  443.                                                             }
  444.                                                             if(eval("\x01") == 224)
  445.                                                             {
  446.                                                                set("\x01",eval("\x01") - 53);
  447.                                                                if(┬º┬ºpop())
  448.                                                                {
  449.                                                                   set("\x01",eval("\x01") + 633);
  450.                                                                }
  451.                                                             }
  452.                                                             else
  453.                                                             {
  454.                                                                if(eval("\x01") == 873)
  455.                                                                {
  456.                                                                   break loop7;
  457.                                                                }
  458.                                                                if(eval("\x01") == 699)
  459.                                                                {
  460.                                                                   set("\x01",eval("\x01") - 19);
  461.                                                                   if(┬º┬ºpop())
  462.                                                                   {
  463.                                                                      set("\x01",eval("\x01") - 174);
  464.                                                                   }
  465.                                                                }
  466.                                                                else if(eval("\x01") == 2)
  467.                                                                {
  468.                                                                   set("\x01",eval("\x01") + 936);
  469.                                                                   if(┬º┬ºpop())
  470.                                                                   {
  471.                                                                      set("\x01",eval("\x01") - 416);
  472.                                                                   }
  473.                                                                }
  474.                                                                else if(eval("\x01") == 935)
  475.                                                                {
  476.                                                                   set("\x01",eval("\x01") - 204);
  477.                                                                   ┬º┬ºpush(true);
  478.                                                                }
  479.                                                                else if(eval("\x01") == 402)
  480.                                                                {
  481.                                                                   set("\x01",eval("\x01") + 308);
  482.                                                                   if(┬º┬ºpop())
  483.                                                                   {
  484.                                                                      set("\x01",eval("\x01") + 275);
  485.                                                                   }
  486.                                                                }
  487.                                                                else if(eval("\x01") == 747)
  488.                                                                {
  489.                                                                   set("\x01",eval("\x01") - 381);
  490.                                                                   if(┬º┬ºpop())
  491.                                                                   {
  492.                                                                      set("\x01",eval("\x01") + 321);
  493.                                                                   }
  494.                                                                }
  495.                                                                else if(eval("\x01") == 731)
  496.                                                                {
  497.                                                                   set("\x01",eval("\x01") - 341);
  498.                                                                   if(┬º┬ºpop())
  499.                                                                   {
  500.                                                                      set("\x01",eval("\x01") + 187);
  501.                                                                   }
  502.                                                                }
  503.                                                                else
  504.                                                                {
  505.                                                                   if(eval("\x01") == 390)
  506.                                                                   {
  507.                                                                      set("\x01",eval("\x01") + 187);
  508.                                                                      break loop0;
  509.                                                                   }
  510.                                                                   if(eval("\x01") == 577)
  511.                                                                   {
  512.                                                                      set("\x01",eval("\x01") + 169);
  513.                                                                      continueAfter = getTimer() + 1500;
  514.                                                                      break loop0;
  515.                                                                   }
  516.                                                                   if(eval("\x01") == 946)
  517.                                                                   {
  518.                                                                      set("\x01",eval("\x01") - 199);
  519.                                                                      ┬º┬ºpush(true);
  520.                                                                   }
  521.                                                                   else if(eval("\x01") == 610)
  522.                                                                   {
  523.                                                                      set("\x01",eval("\x01") - 462);
  524.                                                                      if(┬º┬ºpop())
  525.                                                                      {
  526.                                                                         set("\x01",eval("\x01") + 798);
  527.                                                                      }
  528.                                                                   }
  529.                                                                   else
  530.                                                                   {
  531.                                                                      if(eval("\x01") != 506)
  532.                                                                      {
  533.                                                                         break loop0;
  534.                                                                      }
  535.                                                                      set("\x01",eval("\x01") + 104);
  536.                                                                      ┬º┬ºpush(true);
  537.                                                                   }
  538.                                                                }
  539.                                                             }
  540.                                                          }
  541.                                                       }
  542.                                                    }
  543.                                                    continue;
  544.                                                 }
  545.                                                 set("\x01",eval("\x01") + 633);
  546.                                                 while(true)
  547.                                                 {
  548.                                                    if(┬º┬ºpop())
  549.                                                    {
  550.                                                       set("\x01",eval("\x01") - 398);
  551.                                                       gotoAndStop("blank");
  552.                                                       play();
  553.                                                       break loop0;
  554.                                                    }
  555.                                                    if(eval("\x01") == 953)
  556.                                                    {
  557.                                                       set("\x01",eval("\x01") - 184);
  558.                                                       ┬º┬ºpush(true);
  559.                                                    }
  560.                                                    else if(eval("\x01") == 64)
  561.                                                    {
  562.                                                       set("\x01",eval("\x01") + 496);
  563.                                                       ┬º┬ºpush(true);
  564.                                                    }
  565.                                                    else if(eval("\x01") == 504)
  566.                                                    {
  567.                                                       set("\x01",eval("\x01") - 73);
  568.                                                       ┬º┬ºpush(true);
  569.                                                    }
  570.                                                    else
  571.                                                    {
  572.                                                       if(eval("\x01") == 707)
  573.                                                       {
  574.                                                          set("\x01",eval("\x01") + 246);
  575.                                                          nextFrame();
  576.                                                          setProperty(┬º┬ºpop(), _X, getTimer());
  577.                                                          nextFrame();
  578.                                                          var ┬º┬ºpop() = ┬º┬ºpop();
  579.                                                          nextFrame();
  580.                                                          ┬º┬ºpush([]);
  581.                                                          break loop0;
  582.                                                       }
  583.                                                       if(eval("\x01") == 197)
  584.                                                       {
  585.                                                          set("\x01",eval("\x01") + 391);
  586.                                                          ┬º┬ºpush(true);
  587.                                                       }
  588.                                                       else
  589.                                                       {
  590.                                                          if(eval("\x01") == 221)
  591.                                                          {
  592.                                                             set("\x01",eval("\x01") - 24);
  593.                                                             break loop0;
  594.                                                          }
  595.                                                          if(eval("\x01") == 431)
  596.                                                          {
  597.                                                             set("\x01",eval("\x01") + 199);
  598.                                                             if(┬º┬ºpop())
  599.                                                             {
  600.                                                                set("\x01",eval("\x01") + 119);
  601.                                                             }
  602.                                                          }
  603.                                                          else if(eval("\x01") == 682)
  604.                                                          {
  605.                                                             set("\x01",eval("\x01") - 436);
  606.                                                             ┬º┬ºpush(true);
  607.                                                          }
  608.                                                          else
  609.                                                          {
  610.                                                             if(eval("\x01") != 753)
  611.                                                             {
  612.                                                                break loop0;
  613.                                                             }
  614.                                                             set("\x01",eval("\x01") - 675);
  615.                                                             if(┬º┬ºpop())
  616.                                                             {
  617.                                                                set("\x01",eval("\x01") + 604);
  618.                                                             }
  619.                                                          }
  620.                                                       }
  621.                                                    }
  622.                                                    while(true)
  623.                                                    {
  624.                                                       if(eval("\x01") == 719)
  625.                                                       {
  626.                                                          set("\x01",eval("\x01") - 291);
  627.                                                          ┬º┬ºpush(true);
  628.                                                       }
  629.                                                       else if(eval("\x01") == 560)
  630.                                                       {
  631.                                                          set("\x01",eval("\x01") + 319);
  632.                                                          if(┬º┬ºpop())
  633.                                                          {
  634.                                                             set("\x01",eval("\x01") + 22);
  635.                                                          }
  636.                                                       }
  637.                                                       else if(eval("\x01") == 246)
  638.                                                       {
  639.                                                          set("\x01",eval("\x01") - 25);
  640.                                                          if(┬º┬ºpop())
  641.                                                          {
  642.                                                             set("\x01",eval("\x01") - 24);
  643.                                                          }
  644.                                                       }
  645.                                                       else if(eval("\x01") == 749)
  646.                                                       {
  647.                                                          set("\x01",eval("\x01") + 4);
  648.                                                          ┬º┬ºpush(true);
  649.                                                       }
  650.                                                       else
  651.                                                       {
  652.                                                          if(eval("\x01") == 879)
  653.                                                          {
  654.                                                             set("\x01",eval("\x01") + 22);
  655.                                                             break loop0;
  656.                                                          }
  657.                                                          if(eval("\x01") == 784)
  658.                                                          {
  659.                                                             set("\x01",eval("\x01") - 435);
  660.                                                             if(┬º┬ºpop())
  661.                                                             {
  662.                                                                set("\x01",eval("\x01") - 173);
  663.                                                             }
  664.                                                          }
  665.                                                          else if(eval("\x01") == 573)
  666.                                                          {
  667.                                                             set("\x01",eval("\x01") + 211);
  668.                                                             ┬º┬ºpush(true);
  669.                                                          }
  670.                                                          else if(eval("\x01") == 428)
  671.                                                          {
  672.                                                             set("\x01",eval("\x01") + 279);
  673.                                                             if(┬º┬ºpop())
  674.                                                             {
  675.                                                                set("\x01",eval("\x01") + 246);
  676.                                                             }
  677.                                                          }
  678.                                                          else if(eval("\x01") == 176)
  679.                                                          {
  680.                                                             set("\x01",eval("\x01") + 778);
  681.                                                             ┬º┬ºpush(true);
  682.                                                          }
  683.                                                          else
  684.                                                          {
  685.                                                             if(eval("\x01") == 349)
  686.                                                             {
  687.                                                                set("\x01",eval("\x01") - 173);
  688.                                                                nextFrame();
  689.                                                                nextFrame();
  690.                                                                ┬º┬ºpush([]);
  691.                                                                break loop0;
  692.                                                             }
  693.                                                             if(eval("\x01") == 581)
  694.                                                             {
  695.                                                                set("\x01",eval("\x01") - 8);
  696.                                                                break loop0;
  697.                                                             }
  698.                                                             if(eval("\x01") == 630)
  699.                                                             {
  700.                                                                set("\x01",eval("\x01") + 119);
  701.                                                                break loop0;
  702.                                                             }
  703.                                                             if(eval("\x01") == 375)
  704.                                                             {
  705.                                                                set("\x01",eval("\x01") - 311);
  706.                                                                break loop0;
  707.                                                             }
  708.                                                             if(eval("\x01") == 769)
  709.                                                             {
  710.                                                                set("\x01",eval("\x01") - 188);
  711.                                                                if(┬º┬ºpop())
  712.                                                                {
  713.                                                                   set("\x01",eval("\x01") - 8);
  714.                                                                }
  715.                                                             }
  716.                                                             else if(eval("\x01") == 588)
  717.                                                             {
  718.                                                                set("\x01",eval("\x01") - 213);
  719.                                                                if(┬º┬ºpop())
  720.                                                                {
  721.                                                                   set("\x01",eval("\x01") - 311);
  722.                                                                }
  723.                                                             }
  724.                                                             else
  725.                                                             {
  726.                                                                if(eval("\x01") == 340)
  727.                                                                {
  728.                                                                   set("\x01",eval("\x01") + 164);
  729.                                                                   break loop0;
  730.                                                                }
  731.                                                                if(eval("\x01") == 78)
  732.                                                                {
  733.                                                                   set("\x01",eval("\x01") + 604);
  734.                                                                   break loop0;
  735.                                                                }
  736.                                                                if(eval("\x01") != 954)
  737.                                                                {
  738.                                                                   break;
  739.                                                                }
  740.                                                                set("\x01",eval("\x01") - 614);
  741.                                                                if(┬º┬ºpop())
  742.                                                                {
  743.                                                                   set("\x01",eval("\x01") + 164);
  744.                                                                }
  745.                                                             }
  746.                                                          }
  747.                                                       }
  748.                                                    }
  749.                                                 }
  750.                                              }
  751.                                           }
  752.                                           set("\x01",eval("\x01") + 62);
  753.                                           break loop0;
  754.                                        }
  755.                                        if(eval("\x01") == 161)
  756.                                        {
  757.                                           set("\x01",eval("\x01") + 823);
  758.                                           break loop0;
  759.                                        }
  760.                                        if(eval("\x01") == 663)
  761.                                        {
  762.                                           set("\x01",eval("\x01") - 485);
  763.                                           if(┬º┬ºpop())
  764.                                           {
  765.                                              set("\x01",eval("\x01") - 3);
  766.                                           }
  767.                                        }
  768.                                        else if(eval("\x01") == 768)
  769.                                        {
  770.                                           set("\x01",eval("\x01") - 689);
  771.                                           if(┬º┬ºpop())
  772.                                           {
  773.                                              set("\x01",eval("\x01") + 427);
  774.                                           }
  775.                                        }
  776.                                        else
  777.                                        {
  778.                                           if(eval("\x01") != 294)
  779.                                           {
  780.                                              if(eval("\x01") == 506)
  781.                                              {
  782.                                                 set("\x01",eval("\x01") - 91);
  783.                                                 stop();
  784.                                                 break loop0;
  785.                                              }
  786.                                              if(eval("\x01") == 89)
  787.                                              {
  788.                                                 set("\x01",eval("\x01") + 205);
  789.                                              }
  790.                                              break loop0;
  791.                                           }
  792.                                           set("\x01",eval("\x01") + 369);
  793.                                           ┬º┬ºpush(true);
  794.                                        }
  795.                                     }
  796.                                  }
  797.                               }
  798.                               continue;
  799.                            }
  800.                            set("\x01",eval("\x01") + 8);
  801.                            loop11:
  802.                            while(true)
  803.                            {
  804.                               ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  805.                               _loc2_[┬º┬ºconstant(30)] = ┬º┬ºconstant(35);
  806.                               delete _loc2_[┬º┬ºconstant(32)];
  807.                               _loc2_[┬º┬ºconstant(34)]();
  808.                               while(true)
  809.                               {
  810.                                  _loc2_[┬º┬ºconstant(23)] = 80 * (1 - eval(┬º┬ºconstant(25))[┬º┬ºconstant(28)]) + _loc1_ * 160;
  811.                                  var _loc1_ = _loc1_ + 1;
  812.                                  if(_loc1_ >= 3)
  813.                                  {
  814.                                     break;
  815.                                  }
  816.                                  var _loc2_ = eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(27) + _loc1_];
  817.                                  if(_loc1_ < eval(┬º┬ºconstant(25))[┬º┬ºconstant(28)])
  818.                                  {
  819.                                     _loc2_[┬º┬ºconstant(29)] = 1;
  820.                                     _loc2_[┬º┬ºconstant(30)] = eval(┬º┬ºconstant(25))[_loc1_][┬º┬ºconstant(31)];
  821.                                     _loc2_[┬º┬ºconstant(32)] = eval(┬º┬ºconstant(25))[_loc1_][┬º┬ºconstant(33)];
  822.                                     _loc2_[┬º┬ºconstant(34)]();
  823.                                     continue;
  824.                                  }
  825.                                  continue loop11;
  826.                               }
  827.                               if(eval(┬º┬ºconstant(25))[┬º┬ºconstant(28)] == 0)
  828.                               {
  829.                                  _loc2_ = eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(36)];
  830.                                  _loc2_[┬º┬ºconstant(29)] = 1;
  831.                                  _loc2_[┬º┬ºconstant(30)] = ┬º┬ºconstant(37);
  832.                                  _loc2_[┬º┬ºconstant(32)] = eval(┬º┬ºconstant(38));
  833.                                  _loc2_[┬º┬ºconstant(34)]();
  834.                                  _loc2_[┬º┬ºconstant(23)] = 0;
  835.                               }
  836.                               eval(┬º┬ºconstant(41))[┬º┬ºconstant(42)] = ┬º┬ºconstant(43);
  837.                               set(┬º┬ºconstant(17),┬º┬ºconstant(44));
  838.                               set(┬º┬ºconstant(17),┬º┬ºconstant(19));
  839.                               set(┬º┬ºconstant(21),0.5);
  840.                               set(┬º┬ºconstant(25),[]);
  841.                               set(┬º┬ºconstant(45),new eval(┬º┬ºconstant(46))[┬º┬ºconstant(47)]());
  842.                               eval(┬º┬ºconstant(45))[┬º┬ºconstant(53)](┬º┬ºconstant(52),{(┬º┬ºconstant(48)):┬º┬ºconstant(49),(┬º┬ºconstant(50)):┬º┬ºconstant(51)});
  843.                               eval(┬º┬ºconstant(45))[┬º┬ºconstant(53)](┬º┬ºconstant(56),{(┬º┬ºconstant(48)):┬º┬ºconstant(49),(┬º┬ºconstant(50)):┬º┬ºconstant(51),(┬º┬ºconstant(54)):┬º┬ºconstant(55)});
  844.                               if(eval(┬º┬ºconstant(57))[┬º┬ºconstant(5)] == null)
  845.                               {
  846.                                  eval(┬º┬ºconstant(57))[┬º┬ºconstant(5)] = new ┬º\┬º\┬ºconstant(58)┬º();
  847.                               }
  848.                               eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)] = eval(┬º┬ºconstant(41));
  849.                               set(┬º┬ºconstant(59),0);
  850.                               set(┬º┬ºconstant(60),new ┬º\┬º\┬ºconstant(26)┬º());
  851.                               gotoAndStop("blank");
  852.                               play();
  853.                               eval(┬º┬ºconstant(5))[┬º┬ºconstant(61)] = function(windowType, titleCopy, bodyCopy, buttons)
  854.                               {
  855.                                  set(┬º┬ºconstant(17),┬º┬ºconstant(44));
  856.                                  set(┬º┬ºconstant(17),┬º┬ºconstant(19));
  857.                                  set(┬º┬ºconstant(21),0.5);
  858.                                  if(windowType == null)
  859.                                  {
  860.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(62)] = ┬º┬ºconstant(63);
  861.                                  }
  862.                                  else if(windowType == ┬º┬ºconstant(64))
  863.                                  {
  864.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(62)] = ┬º┬ºconstant(63);
  865.                                  }
  866.                                  else
  867.                                  {
  868.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(62)] = windowType;
  869.                                  }
  870.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(25)] = buttons;
  871.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(65)] = titleCopy;
  872.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(66)] = bodyCopy;
  873.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(3)](eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(62)]);
  874.                                  if(!eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(59)])
  875.                                  {
  876.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(0)][┬º┬ºconstant(12)] = 20;
  877.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(0)][┬º┬ºconstant(13)] = 20;
  878.                                  }
  879.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(23)] = eval(┬º┬ºconstant(5))[┬º┬ºconstant(67)][┬º┬ºconstant(68)][┬º┬ºconstant(69)] / 2;
  880.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(22)] = eval(┬º┬ºconstant(5))[┬º┬ºconstant(67)][┬º┬ºconstant(68)][┬º┬ºconstant(70)] / 2;
  881.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(71)][┬º┬ºconstant(23)] = (- eval(┬º┬ºconstant(5))[┬º┬ºconstant(67)][┬º┬ºconstant(68)][┬º┬ºconstant(69)]) / 2;
  882.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(71)][┬º┬ºconstant(22)] = (- eval(┬º┬ºconstant(5))[┬º┬ºconstant(67)][┬º┬ºconstant(68)][┬º┬ºconstant(70)]) / 2;
  883.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(71)][┬º┬ºconstant(72)] = eval(┬º┬ºconstant(5))[┬º┬ºconstant(67)][┬º┬ºconstant(68)][┬º┬ºconstant(69)];
  884.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(71)][┬º┬ºconstant(73)] = eval(┬º┬ºconstant(5))[┬º┬ºconstant(67)][┬º┬ºconstant(68)][┬º┬ºconstant(70)];
  885.                                  eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(71)][┬º┬ºconstant(74)] = 0;
  886.                                  if(!eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(59)])
  887.                                  {
  888.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(59)] = 1;
  889.                                     eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(71)][┬º┬ºconstant(24)](┬º┬ºconstant(75),50,eval(┬º┬ºconstant(21)));
  890.                                  }
  891.                               };
  892.                            }
  893.                         }
  894.                      }
  895.                      set("\x01",eval("\x01") + 463);
  896.                   }
  897.                   set("\x01",eval("\x01") + 527);
  898.                   break;
  899.                }
  900.                if(eval("\x01") == 847)
  901.                {
  902.                   set("\x01",eval("\x01") - 633);
  903.                   ┬º┬ºpush(true);
  904.                }
  905.                else
  906.                {
  907.                   if(eval("\x01") == 398)
  908.                   {
  909.                      set("\x01",eval("\x01") - 33);
  910.                      ┬º┬ºpush({});
  911.                      break;
  912.                   }
  913.                   if(eval("\x01") == 955)
  914.                   {
  915.                      set("\x01",eval("\x01") - 865);
  916.                      break;
  917.                   }
  918.                   if(eval("\x01") == 367)
  919.                   {
  920.                      set("\x01",eval("\x01") + 481);
  921.                      if(┬º┬ºpop())
  922.                      {
  923.                         set("\x01",eval("\x01") + 75);
  924.                      }
  925.                   }
  926.                   else if(eval("\x01") == 792)
  927.                   {
  928.                      set("\x01",eval("\x01") - 37);
  929.                      ┬º┬ºpush(true);
  930.                   }
  931.                   else if(eval("\x01") == 330)
  932.                   {
  933.                      set("\x01",eval("\x01") + 68);
  934.                      if(┬º┬ºpop())
  935.                      {
  936.                         set("\x01",eval("\x01") - 33);
  937.                      }
  938.                   }
  939.                   else if(eval("\x01") == 899)
  940.                   {
  941.                      set("\x01",eval("\x01") - 324);
  942.                      ┬º┬ºpush(true);
  943.                   }
  944.                   else
  945.                   {
  946.                      if(eval("\x01") == 115)
  947.                      {
  948.                         set("\x01",eval("\x01") + 417);
  949.                         stop();
  950.                         loop1:
  951.                         while(true)
  952.                         {
  953.                            set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  954.                            if(┬º┬ºpop())
  955.                            {
  956.                               set("\x01",eval("\x01") + 588);
  957.                            }
  958.                            while(true)
  959.                            {
  960.                               if(eval("\x01") == 125)
  961.                               {
  962.                                  set("\x01",eval("\x01") + 572);
  963.                                  ┬º┬ºpush(true);
  964.                                  continue;
  965.                               }
  966.                               if(eval("\x01") == 415)
  967.                               {
  968.                                  set("\x01",eval("\x01") + 337);
  969.                                  if(┬º┬ºpop())
  970.                                  {
  971.                                     set("\x01",eval("\x01") - 640);
  972.                                  }
  973.                                  continue;
  974.                               }
  975.                               if(eval("\x01") == 249)
  976.                               {
  977.                                  break loop1;
  978.                               }
  979.                               if(eval("\x01") == 414)
  980.                               {
  981.                                  set("\x01",eval("\x01") - 182);
  982.                                  ┬º┬ºpush(true);
  983.                                  continue;
  984.                               }
  985.                               if(eval("\x01") == 388)
  986.                               {
  987.                                  set("\x01",eval("\x01") - 370);
  988.                                  ┬º┬ºpush(┬º┬ºpop() instanceof ┬º┬ºpop());
  989.                                  break loop0;
  990.                               }
  991.                               if(eval("\x01") == 466)
  992.                               {
  993.                                  set("\x01",eval("\x01") + 143);
  994.                                  ┬º┬ºpush(true);
  995.                                  continue;
  996.                               }
  997.                               if(eval("\x01") == 166)
  998.                               {
  999.                                  set("\x01",eval("\x01") + 300);
  1000.                                  ┬º┬ºpop();
  1001.                                  break loop0;
  1002.                               }
  1003.                               if(eval("\x01") == 982)
  1004.                               {
  1005.                                  set("\x01",eval("\x01") - 940);
  1006.                                  if(┬º┬ºpop())
  1007.                                  {
  1008.                                     set("\x01",eval("\x01") + 372);
  1009.                                  }
  1010.                                  continue;
  1011.                               }
  1012.                               if(eval("\x01") == 752)
  1013.                               {
  1014.                                  set("\x01",eval("\x01") - 640);
  1015.                                  nextFrame();
  1016.                                  ┬º┬ºpush(┬º┬ºpop() < ┬º┬ºpop());
  1017.                                  break loop0;
  1018.                               }
  1019.                               if(eval("\x01") == 112)
  1020.                               {
  1021.                                  set("\x01",eval("\x01") - 111);
  1022.                                  ┬º┬ºpush(true);
  1023.                                  continue;
  1024.                               }
  1025.                               if(eval("\x01") == 356)
  1026.                               {
  1027.                                  set("\x01",eval("\x01") - 107);
  1028.                                  if(┬º┬ºpop())
  1029.                                  {
  1030.                                     set("\x01",eval("\x01") - 153);
  1031.                                  }
  1032.                                  continue;
  1033.                               }
  1034.                               if(eval("\x01") == 18)
  1035.                               {
  1036.                                  set("\x01",eval("\x01") + 397);
  1037.                                  ┬º┬ºpush(true);
  1038.                                  continue;
  1039.                               }
  1040.                               if(eval("\x01") == 232)
  1041.                               {
  1042.                                  set("\x01",eval("\x01") + 156);
  1043.                                  if(┬º┬ºpop())
  1044.                                  {
  1045.                                     set("\x01",eval("\x01") - 370);
  1046.                                  }
  1047.                                  continue;
  1048.                               }
  1049.                               if(eval("\x01") == 339)
  1050.                               {
  1051.                                  set("\x01",eval("\x01") + 538);
  1052.                                  ┬º┬ºpush([]);
  1053.                                  break loop0;
  1054.                               }
  1055.                               if(eval("\x01") == 697)
  1056.                               {
  1057.                                  set("\x01",eval("\x01") - 531);
  1058.                                  if(┬º┬ºpop())
  1059.                                  {
  1060.                                     set("\x01",eval("\x01") + 300);
  1061.                                  }
  1062.                                  continue;
  1063.                               }
  1064.                               if(eval("\x01") == 42)
  1065.                               {
  1066.                                  set("\x01",eval("\x01") + 372);
  1067.                                  ┬º┬ºpush(typeof typeof (┬º┬ºpop() eq ┬º┬ºpop()));
  1068.                                  break loop0;
  1069.                               }
  1070.                               if(eval("\x01") == 609)
  1071.                               {
  1072.                                  break;
  1073.                               }
  1074.                               if(eval("\x01") == 698)
  1075.                               {
  1076.                                  set("\x01",eval("\x01") + 284);
  1077.                                  ┬º┬ºpush(true);
  1078.                                  continue;
  1079.                               }
  1080.                               if(eval("\x01") == 797)
  1081.                               {
  1082.                                  set("\x01",eval("\x01") - 563);
  1083.                                  nextFrame();
  1084.                                  stop();
  1085.                                  ┬º┬ºpush(mbchr(┬º┬ºpop()));
  1086.                                  break loop0;
  1087.                               }
  1088.                               if(eval("\x01") != 110)
  1089.                               {
  1090.                                  if(eval("\x01") == 1)
  1091.                                  {
  1092.                                     set("\x01",eval("\x01") + 796);
  1093.                                     if(┬º┬ºpop())
  1094.                                     {
  1095.                                        set("\x01",eval("\x01") - 563);
  1096.                                     }
  1097.                                  }
  1098.                                  else if(eval("\x01") == 234)
  1099.                                  {
  1100.                                     set("\x01",eval("\x01") + 309);
  1101.                                     ┬º┬ºpush(true);
  1102.                                  }
  1103.                                  else if(eval("\x01") == 543)
  1104.                                  {
  1105.                                     set("\x01",eval("\x01") - 341);
  1106.                                     if(┬º┬ºpop())
  1107.                                     {
  1108.                                        set("\x01",eval("\x01") + 479);
  1109.                                     }
  1110.                                  }
  1111.                                  else
  1112.                                  {
  1113.                                     if(eval("\x01") == 202)
  1114.                                     {
  1115.                                        set("\x01",eval("\x01") + 479);
  1116.                                        break loop0;
  1117.                                     }
  1118.                                     if(eval("\x01") == 681)
  1119.                                     {
  1120.                                        set("\x01",eval("\x01") - 325);
  1121.                                        ┬º┬ºpush(true);
  1122.                                     }
  1123.                                     else if(eval("\x01") == 96)
  1124.                                     {
  1125.                                        set("\x01",eval("\x01") + 302);
  1126.                                        ┬º┬ºpush(true);
  1127.                                     }
  1128.                                     else
  1129.                                     {
  1130.                                        if(eval("\x01") != 398)
  1131.                                        {
  1132.                                           if(eval("\x01") == 877)
  1133.                                           {
  1134.                                              set("\x01",eval("\x01") - 497);
  1135.                                              fieldName = "bodyText_txt";
  1136.                                           }
  1137.                                           break loop0;
  1138.                                        }
  1139.                                        set("\x01",eval("\x01") - 59);
  1140.                                        if(┬º┬ºpop())
  1141.                                        {
  1142.                                           set("\x01",eval("\x01") + 538);
  1143.                                        }
  1144.                                     }
  1145.                                  }
  1146.                                  continue;
  1147.                               }
  1148.                               set("\x01",eval("\x01") + 588);
  1149.                               toggleHighQuality();
  1150.                               ┬º┬ºpop()[┬º┬ºpop() + ┬º┬ºpop()][┬º┬ºconstant(24)]();
  1151.                               eval(┬º┬ºconstant(5))[┬º┬ºconstant(6)][┬º┬ºconstant(3)](┬º┬ºconstant(77));
  1152.                            }
  1153.                         }
  1154.                         set("\x01",eval("\x01") - 153);
  1155.                         break;
  1156.                      }
  1157.                      if(eval("\x01") == 805)
  1158.                      {
  1159.                         set("\x01",eval("\x01") - 188);
  1160.                         if(┬º┬ºpop())
  1161.                         {
  1162.                            set("\x01",eval("\x01") + 282);
  1163.                         }
  1164.                      }
  1165.                      else
  1166.                      {
  1167.                         if(eval("\x01") == 994)
  1168.                         {
  1169.                            set("\x01",eval("\x01") - 768);
  1170.                            break;
  1171.                         }
  1172.                         if(eval("\x01") == 90)
  1173.                         {
  1174.                            set("\x01",eval("\x01") + 558);
  1175.                            ┬º┬ºpush(true);
  1176.                         }
  1177.                         else
  1178.                         {
  1179.                            if(eval("\x01") == 760)
  1180.                            {
  1181.                               set("\x01",eval("\x01") + 32);
  1182.                               ┬º┬ºpop() extends new ┬º┬ºpop()[┬º┬ºpop() > ┬º┬ºpop()]();
  1183.                               ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  1184.                               break;
  1185.                            }
  1186.                            if(eval("\x01") == 755)
  1187.                            {
  1188.                               set("\x01",eval("\x01") - 640);
  1189.                               if(┬º┬ºpop())
  1190.                               {
  1191.                                  set("\x01",eval("\x01") + 417);
  1192.                               }
  1193.                            }
  1194.                            else
  1195.                            {
  1196.                               if(eval("\x01") == 848)
  1197.                               {
  1198.                                  set("\x01",eval("\x01") + 75);
  1199.                                  prevFrame();
  1200.                                  break;
  1201.                               }
  1202.                               if(eval("\x01") == 226)
  1203.                               {
  1204.                                  set("\x01",eval("\x01") + 336);
  1205.                                  ┬º┬ºpush(true);
  1206.                               }
  1207.                               else
  1208.                               {
  1209.                                  if(eval("\x01") == 200)
  1210.                                  {
  1211.                                     set("\x01",eval("\x01") + 570);
  1212.                                     break;
  1213.                                  }
  1214.                                  if(eval("\x01") != 562)
  1215.                                  {
  1216.                                     if(eval("\x01") == 770)
  1217.                                     {
  1218.                                        set("\x01",eval("\x01") - 228);
  1219.                                        if(getTimer() < continueAfter)
  1220.                                        {
  1221.                                           gotoAndPlay(_currentframe - 1);
  1222.                                        }
  1223.                                     }
  1224.                                     break;
  1225.                                  }
  1226.                                  set("\x01",eval("\x01") - 457);
  1227.                                  if(┬º┬ºpop())
  1228.                                  {
  1229.                                     set("\x01",eval("\x01") + 291);
  1230.                                  }
  1231.                               }
  1232.                            }
  1233.                         }
  1234.                      }
  1235.                   }
  1236.                }
  1237.                continue;
  1238.                ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1239.                break;
  1240.             }
  1241.             set("\x01",eval("\x01") - 43);
  1242.             if(┬º┬ºpop())
  1243.             {
  1244.                set("\x01",eval("\x01") + 570);
  1245.             }
  1246.          }
  1247.       }
  1248.    }
  1249. }
  1250.