This week only. Pastebin PRO Accounts Christmas Special! Don't miss out!Want more features on Pastebin? Sign Up, it's FREE!
Guest

Moh2010.swf ActionScript Decompilation

By: eromang on Sep 14th, 2012  |  syntax: ActionScript  |  size: 11.23 KB  |  views: 1,974  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. //ActionScript 3.0
  2. //  class Ϣߐ
  3. package
  4. {
  5.     import flash.display.*;
  6.     import flash.events.*;
  7.     import flash.net.*;
  8.     import flash.system.*;
  9.     import flash.utils.*;
  10.     import laan.smart.proxies.filesystem.*;
  11.    
  12.     public dynamic class Ϣߐ extends flash.display.MovieClip
  13.     {
  14.         public function Ϣߐ()
  15.         {
  16.             super();
  17.             if (flash.system.Security.sandboxType != "application")
  18.             {
  19.                 flash.system.Security.allowDomain("*");
  20.             }
  21.             if (stage)
  22.             {
  23.                 this.init();
  24.             }
  25.             else
  26.             {
  27.                 addEventListener(flash.events.Event.ADDED_TO_STAGE, this.init);
  28.             }
  29.             return;
  30.         }
  31.  
  32.         internal function init(arg1:flash.events.Event):void
  33.         {
  34.             var loc6:*=null;
  35.             var loc5:*=null;
  36.             var loc4:*=null;
  37.             var loc3:*=null;
  38.             var loc2:*=null;
  39.             var loc1:*=null;
  40.             loc4 = null;
  41.             loc5 = null;
  42.             loc6 = 0;
  43.             loc1 = this.init[0];
  44.             loc2 = this.init[1];
  45.             loc3 = 3;
  46.             while (loc3-- > 0)
  47.             {
  48.                 (loc4 = new flash.utils.ByteArray()).writeBytes(loc2);
  49.                 loc4.position = loc4.length;
  50.                 loc4.endian = flash.utils.Endian.LITTLE_ENDIAN;
  51.                 loc5 = new flash.utils.ByteArray();
  52.                 loc6 = Math.random() * Math.min(loc1, 2 * 1024 * 1024);
  53.                 while (loc5.length < loc6)
  54.                 {
  55.                     loc5.writeBytes(loc2, Math.random() * loc2.length / 3);
  56.                 }
  57.                 loc5.length = loc6;
  58.                 if (loc5.length >= 63)
  59.                 {
  60.                     loc4.writeShort(87 << 6 | 63);
  61.                     loc4.writeUnsignedInt(loc5.length);
  62.                 }
  63.                 else
  64.                 {
  65.                     loc4.writeShort(87 << 6 | loc5.length);
  66.                 }
  67.                 loc4.writeBytes(loc5);
  68.                 loc4.writeShort(1 << 6);
  69.                 loc4.writeShort(0);
  70.                 loc4.position = 4;
  71.                 loc4.writeUnsignedInt(loc4.length);
  72.                 this.init.writeBytes(loc4);
  73.                 if (!(this.init.length > 30 * 1024 * 1024))
  74.                 {
  75.                     continue;
  76.                 }
  77.                 removeEventListener(flash.events.Event.ENTER_FRAME, this.init);
  78.                 break;
  79.             }
  80.             return;
  81.         }
  82.  
  83.         internal function init(arg1:flash.utils.ByteArray):void
  84.         {
  85.             var loc3:*=null;
  86.             var loc2:*=null;
  87.             var loc1:*=null;
  88.             this.init = [];
  89.             loc1 = arg1.readUnsignedInt();
  90.             loc2 = arg1.readUnsignedInt();
  91.             loc3 = new flash.utils.ByteArray();
  92.             arg1.readBytes(loc3, 0, loc2);
  93.             this.init = new flash.utils.ByteArray();
  94.             this.init.endian = flash.utils.Endian.LITTLE_ENDIAN;
  95.             this.init = [loc1, loc3];
  96.             addEventListener(flash.events.Event.ENTER_FRAME, this.init);
  97.             this.init(null);
  98.             return;
  99.         }
  100.  
  101.         internal function init(arg1:flash.events.Event=null):void
  102.         {
  103.             var loc1:*=null;
  104.             loc1 = null;
  105.             if (arg1)
  106.             {
  107.                 removeEventListener(flash.events.Event.ADDED_TO_STAGE, this.init);
  108.             }
  109.             this.LOADING_BAR_CLASS = new flash.system.LoaderContext(false, flash.system.ApplicationDomain.currentDomain);
  110.             if (this.LOADING_BAR_CLASS.hasOwnProperty("allowLoadBytesCodeExecution"))
  111.             {
  112.                 Object(this.LOADING_BAR_CLASS).allowLoadBytesCodeExecution = true;
  113.             }
  114.             if (this.LOADING_BAR_CLASS.hasOwnProperty("parameters"))
  115.             {
  116.                 Object(this.LOADING_BAR_CLASS)["parameters"] = stage.loaderInfo.parameters;
  117.             }
  118.             flash.display.StageAlign.prototype["@doswf__s"] = stage;
  119.             flash.display.StageAlign.prototype.setPropertyIsEnumerable("@doswf__s", false);
  120.             flash.display.LoaderInfo.prototype["@doswf__u"] = stage.loaderInfo.url;
  121.             flash.display.LoaderInfo.prototype.setPropertyIsEnumerable("@doswf__u", false);
  122.             flash.display.LoaderInfo.prototype["@doswf__p"] = stage.loaderInfo.parameters;
  123.             flash.display.LoaderInfo.prototype.setPropertyIsEnumerable("@doswf__p", false);
  124.             if (flash.system.ApplicationDomain.currentDomain.hasDefinition(LOADING_BAR_CLASS))
  125.             {
  126.                 loc1 = flash.system.ApplicationDomain.currentDomain.getDefinition(LOADING_BAR_CLASS) as Class;
  127.                 this.LOADING_BAR_CLASS = new loc1() as flash.display.DisplayObject;
  128.                 addChild(this.LOADING_BAR_CLASS);
  129.                 stop();
  130.                 addEventListener(flash.events.Event.ENTER_FRAME, this.init);
  131.             }
  132.             else
  133.             {
  134.                 this.init();
  135.             }
  136.             return;
  137.         }
  138.  
  139.         internal function init():void
  140.         {
  141.             var loc1:*=null;
  142.             loc1 = this.init(new Ϣߑ());
  143.             loc1.uncompress();
  144.             this.init(loc1);
  145.             return;
  146.         }
  147.  
  148.         internal function init(arg1:flash.events.Event):void
  149.         {
  150.             var loc1:*=null;
  151.             loc1 = loaderInfo.bytesLoaded / loaderInfo.bytesTotal;
  152.             Object(this.LOADING_BAR_CLASS).setProgress(this, loc1);
  153.             if (loc1 == 1)
  154.             {
  155.                 removeEventListener(flash.events.Event.ENTER_FRAME, this.init);
  156.                 removeChild(this.LOADING_BAR_CLASS);
  157.                 gotoAndStop(2);
  158.                 this.init();
  159.             }
  160.             return;
  161.         }
  162.  
  163.         internal function init(arg1:flash.utils.ByteArray):void
  164.         {
  165.             var loc3:*=null;
  166.             var loc2:*=null;
  167.             var loc1:*=null;
  168.             arg1.endian = flash.utils.Endian.LITTLE_ENDIAN;
  169.             arg1.position = 0;
  170.             if (arg1.readBoolean())
  171.             {
  172.                 this.init(arg1);
  173.             }
  174.             this.init = arg1.readBoolean();
  175.             loc1 = arg1.readUnsignedInt();
  176.             loc2 = new flash.utils.ByteArray();
  177.             arg1.readBytes(loc2, 0, loc1);
  178.             this.LOADING_BAR_CLASS = new flash.utils.ByteArray();
  179.             arg1.readBytes(this.LOADING_BAR_CLASS);
  180.             (loc3 = new flash.display.Loader()).contentLoaderInfo.addEventListener(flash.events.Event.INIT, this.init);
  181.             loc3.contentLoaderInfo.addEventListener(flash.events.ProgressEvent.PROGRESS, this.init);
  182.             loc3.loadBytes(loc2, this.LOADING_BAR_CLASS);
  183.             return;
  184.         }
  185.  
  186.         internal function init(arg1:flash.events.Event):void
  187.         {
  188.             var loc6:*=null;
  189.             var loc5:*=null;
  190.             var loc4:*=null;
  191.             var loc3:*=null;
  192.             var loc2:*=null;
  193.             var loc1:*=null;
  194.             loc3 = null;
  195.             loc4 = 0;
  196.             loc5 = undefined;
  197.             if (arg1 is flash.events.ProgressEvent)
  198.             {
  199.                 this.init = arg1 as flash.events.ProgressEvent;
  200.                 return;
  201.             }
  202.             loc1 = arg1.target as flash.display.LoaderInfo;
  203.             loc1.removeEventListener(flash.events.Event.INIT, this.init);
  204.             loc1.removeEventListener(flash.events.ProgressEvent.PROGRESS, this.init);
  205.             loc2 = loc1.loader;
  206.             if (this.LOADING_BAR_CLASS)
  207.             {
  208.                 loc2 = new flash.display.Loader();
  209.                 loc2.contentLoaderInfo.addEventListener(flash.events.Event.INIT, this.init);
  210.                 loc2.contentLoaderInfo.addEventListener(flash.events.ProgressEvent.PROGRESS, this.init);
  211.                 loc2.loadBytes(this.LOADING_BAR_CLASS, this.LOADING_BAR_CLASS);
  212.                 this.LOADING_BAR_CLASS = null;
  213.                 return;
  214.             }
  215.             if (parent is flash.display.Stage)
  216.             {
  217.                 if (this.init)
  218.                 {
  219.                     parent.addChildAt(loc2.content, 0);
  220.                     parent.removeChild(this);
  221.                 }
  222.                 else
  223.                 {
  224.                     addChild(loc2);
  225.                 }
  226.             }
  227.             else if (this.init)
  228.             {
  229.                 addChildAt(loc2.content, 0);
  230.             }
  231.             else
  232.             {
  233.                 addChildAt(loc2, 0);
  234.             }
  235.             if (this.init && this.init)
  236.             {
  237.                 if ((loc3 = loc1.content as flash.display.DisplayObjectContainer).hasOwnProperty("@doswf__lph"))
  238.                 {
  239.                     (loc6 = Object(loc3))["@doswf__lph"](this.init);
  240.                 }
  241.                 else
  242.                 {
  243.                     loc4 = 0;
  244.                     while (loc4 < loc3.numChildren)
  245.                     {
  246.                         if ((loc5 = loc3.getChildAt(loc4)).hasOwnProperty("@doswf__lph"))
  247.                         {
  248.                             (loc6 = loc5)["@doswf__lph"](this.init);
  249.                         }
  250.                         ++loc4;
  251.                     }
  252.                 }
  253.             }
  254.             return;
  255.         }
  256.  
  257.         internal function init(arg1:flash.utils.ByteArray):flash.utils.ByteArray
  258.         {
  259.             var loc3:*=null;
  260.             var loc2:*=null;
  261.             var loc1:*=null;
  262.             loc3 = 0;
  263.             arg1.endian = flash.utils.Endian.LITTLE_ENDIAN;
  264.             arg1.position = 0;
  265.             this.init = (arg1.readUnsignedByte() - 1);
  266.             this.init = (arg1.readUnsignedByte() - 1);
  267.             this.init = arg1.readUnsignedInt() - 2;
  268.             this.init = arg1.readUnsignedInt() - 2;
  269.             loc1 = new flash.utils.ByteArray();
  270.             loc1.writeBytes(arg1, arg1.length - this.init, this.init);
  271.             loc2 = 0;
  272.             for (;;)
  273.             {
  274.                 loc3 = 0;
  275.                 while (loc3 < this.init)
  276.                 {
  277.                     loc1[loc2] = loc1[loc2] ^ this.init;
  278.                     ++loc2;
  279.                     if (loc2 >= this.init)
  280.                     {
  281.                         break;
  282.                     }
  283.                     loc3 = loc3 + 5;
  284.                 }
  285.                 loc2 = loc2 + this.init;
  286.                 if (!(loc2 >= this.init))
  287.                 {
  288.                     continue;
  289.                 }
  290.                 break;
  291.             }
  292.             return loc1;
  293.         }
  294.  
  295.         internal static const LOADING_BAR_CLASS:String="_doswf_package.LoadingBarBase";
  296.  
  297.         internal var init:uint;
  298.  
  299.         internal var init:uint;
  300.  
  301.         internal var init:uint;
  302.  
  303.         internal var init:*;
  304.  
  305.         internal var init:uint;
  306.  
  307.         internal var init:*;
  308.  
  309.         internal var init:*;
  310.  
  311.         internal var init:*;
  312.  
  313.         internal var LOADING_BAR_CLASS:*;
  314.  
  315.         internal var LOADING_BAR_CLASS:*;
  316.  
  317.         internal var LOADING_BAR_CLASS:*;
  318.     }
  319. }
  320.  
  321.  
  322. //  class Ϣߑ
  323. package
  324. {
  325.     import flash.utils.*;
  326.    
  327.     public class Ϣߑ extends flash.utils.ByteArray
  328.     {
  329.         public function Ϣߑ()
  330.         {
  331.             super();
  332.             return;
  333.         }
  334.     }
  335. }
clone this paste RAW Paste Data