eromang

Moh2010.swf ActionScript Decompilation

Sep 14th, 2012
2,680
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×