home *** CD-ROM | disk | FTP | other *** search
/ Champak 48 / cdrom_image.iso / Games / dangergirl.swf / scripts / DefineSprite_438 / frame_11 / DoAction.as
Encoding:
Text File  |  2007-10-01  |  60.6 KB  |  988 lines

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