The software is now like a utility for Decompile files are locked with the above method.
Swf file to your home and provides that any application can Decompile getting there!

Is a simple GUI interface , Just your files Drag and Drop in your program.
Program to break the lock file and extract the original file, and give you.
The extracted files are saved in the original file.
Meanwhile, right-click and select Browse File, you can also select your desired file.

If you find a way to break the locks have security in Flash! you can expand your personal experience to share.

Programming environment:

User Mode program is considered so Both in English and Persian Languages to give enough information to work with.

Program Information:

Version : 1.0.0
Adobe Air Installer : Adobe Air 2.5 or higher
size: 275 kb
Release date :  24 June 2011
Powered by :  Flash CS5.5 , ActionScript 3.o , Adobe Air
Designer and Programmer : Behrouz Pooladrag

Download:

Latest Release MochiDecrypt by format AIR –Be installed on any system that is Have Adobe Air Installer.

Latest Release MochiDecrypt by format EXE -Be installed on any system that is Have Adobe Air Installer.

note:

Windows 7 is better to run that program, right click and click Run as administrator option to run the program.

Changes made in new versions

Version : 1.0.0

The first version was created.

Debug:

If you have a problem or see an error in the program. You can be the same for bug fixes and improvements to the program tell me.

be successful.

In AS3,we’ve two ways of creating objects,one is using the “new” keyword,and the other is to just declare the variable typing its datatype(this method only works for top-level classes like Strings,Arrays,ints,Numbers and so on).

var numberObject:Number = 5; //This is a Number object.
var myOtherNumber:Number = new Number(5); // this is also a Number object.

Lets take a look at how a custom Class is structured:

package myPackage
{
class MyClass
{

}
}

First we’ve the Package,which can be used to group classes with similar functionality or that are meant to work with each other.Using the above example,we could import that class to use like this,based on its package:

//This imports only "MyClass"
import myPackage.MyClass;

//This imports all the classes inside the package "myPackage"
import myPackage.*;

Next,we’ve the class itself,and inside it is where we put our variables,properties and function.Its important to note that the class name should be the same as the file name.In our example,we should name that file “MyClass.as”.

The most important function a class has,is the constructor.That is what let us create an object based on that class.Constructor functions are always public(in AS3).You won’t need a constructor for static classes(more on another tutorial).

public class MyClass
{
//this is the constructor function
public function MyClass() {

}
}

Objects can define how their methods and properties can be accessed by other objects.Those are called “access modifiers“.We’ve 4 types of access modifiers in AS3:

public: Classes,methods or properties declared public can be accessed by any other object.
protected: Methods or properties declared protected can be accessed by any subclass object(more on another tutorial).
private: Methods or properties declared private can be accessed by the object itself only.
internal: The class,property or method can only be used by classes inside this package.

Access modifiers are another step in providing abstraction to programming.It lets you provide an object with methods that are public(can be accessed anywhere),but the complex functionality is hidden through the protected,private and internal modifiers.

To create a custom function or variable for your object,is simple:

public var myVar:String = "This is myVar";

public function myFunction():void {
trace("This is myFunction");
}

To use our created class,we instantiate it using the “new” method

var myObject:MyClass = new MyClass();

To access its method or variables:

trace(myObject.myVar);
myObject.myFunction();

Classes also have properties(which differ abit from variables).They normally are used to set internal variables and possibly run another internal function. To create a property,you need to use the special “get” and “set” method.
“get” is used to retrieve the variable,but not allowing you to change its value(it simulates a read-only enviroment).
“set” is used to write the variable,where you can run custom functions after changing its value:

private var _myProperty:String;

public function get myProperty():String {
return _myProperty;
}

public function set myProperty(value:String):void
{
_myProperty = value;
trace("myProperty value was changed! Value = " + value);
}

The property is then handled just like a variable:

myObject.myProperty = "myValue";
trace(myObject.myProperty);

Output :

myProperty value was changed! Value = myValue
myValue

Flash Player 9 introduced two events (Event.ACTIVATE and Event.DEACTIVATE) that can assist you in fine-tuning your application so that it uses the fewest CPU cycles possible. These events allow you to detect when Flash Player gains or loses focus. As a result, code can be optimized to react to context changes.

Note: Use Event.ACTIVATE and Event.DEACTIVATE events to detect background inactivity and optimize your
application appropriately.

The following code listens to both events and dynamically changes the frame rate to zero when the application loses its focus. For example, the animation can lose focus when the user switches to another tab or puts the application into the background:

var originalFrameRate:uint = stage.frameRate;
var standbyFrameRate:uint = 0;

stage.addEventListener ( Event.ACTIVATE, onActivate );
stage.addEventListener ( Event.ACTIVATE, onDeactivate );

function onActivate ( e:Event ):void
{
// restore original frame rate
stage.frameRate = originalFrameRate;
}

function onDeactivate ( e:Event ):void
{
// set frame rate to 0
stage.frameRate = standbyFrameRate;
}

When the application gains focus again, the frame rate is reset to its original value. Instead of changing the frame rate dynamically, you could also consider making other optimizations, such as freezing and unfreezing objects. The activate and deactivate events allow you to implement a similar mechanism to the “Pause and Resume” feature sometimes found on mobile devices and Net books.

To optimize your code, always freeze and unfreeze your objects. Freezing and unfreezing are important for all objects, but are especially important for display objects. Even if display objects are no longer in the display list and are waiting to be garbage collected, they could still be using CPU-intensive code.

For example, they can still be using Event.ENTER_FRAME. As a result, it is critical to freeze and unfreeze objects properly with the Event.REMOVED_FROM_STAGE and Event.ADDED_TO_STAGE events. The following example shows a movie clip
playing on stage that interacts with the keyboard:

// Listen to keyboard events
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyIsDown);
stage.addEventListener(KeyboardEvent.KEY_UP, keyIsUp);

// Create object to store key states
var keys:Dictionary = new Dictionary(true);

function keyIsDown(e:KeyboardEvent):void
{
// Remember that the key was pressed
keys[e.keyCode] = true;

if (e.keyCode==Keyboard.LEFT || e.keyCode==Keyboard.RIGHT)
{
runningBoy.play();
}
}

function keyIsUp(e:KeyboardEvent):void
{
// Remember that the key was released
keys[e.keyCode] = false;

for each (var value:Boolean in keys)
if ( value ) return;
runningBoy.stop();
}

runningBoy.addEventListener(Event.ENTER_FRAME, handleMovement);
runningBoy.stop();

var currentState:Number = runningBoy.scaleX;
var speed:Number = 15;

function handleMovement(e:Event):void
{
if (keys[Keyboard.RIGHT])
{
e.currentTarget.x += speed;
e.currentTarget.scaleX = currentState;
} else if (keys[Keyboard.LEFT])
{
e.currentTarget.x -= speed;
e.currentTarget.scaleX = -currentState;
}
}

When the Remove button is clicked, the movie clip is removed from the display list:

// Show or remove running boy
showBtn.addEventListener (MouseEvent.CLICK,showIt);
removeBtn.addEventListener (MouseEvent.CLICK,removeIt);

function showIt (e:MouseEvent):void
{
addChild (runningBoy);
}

function removeIt(e:MouseEvent):void
{
if (contains(runningBoy)) removeChild(runningBoy);
}

Even when removed from the display list, the movie clip still dispatches the Event.ENTER_FRAME event. The movie
clip still runs, but it is not rendered. To handle this situation correctly, listen to the proper events and remove event listeners, to prevent CPU-intensive code from being executed:

// Listen to Event.ADDED_TO_STAGE and Event.REMOVED_FROM_STAGE
runningBoy.addEventListener(Event.ADDED_TO_STAGE,activate);
runningBoy.addEventListener(Event.REMOVED_FROM_STAGE,deactivate);

function activate(e:Event):void
{
// Restart everything
e.currentTarget.addEventListener(Event.ENTER_FRAME,handleMovement);
}

function deactivate(e:Event):void
{
// Freeze the running boy – consumes fewer CPU resources when not shown
e.currentTarget.removeEventListener(Event.ENTER_FRAME,handleMovement);
e.currentTarget.stop();
}

When the Show button is pressed, the movie clip is restarted, it listens to Event.ENTER_FRAME events again, and the
keyboard correctly controls the movie clip.

Note: If a display object is removed from the display list, setting its reference to null after removing it does not ensure that the object is frozen. If the garbage collector doesn’t run, the object continues to consume memory and CPU processing, even though the object is no longer displayed. To make sure that the object consumes the least CPU processing possible, make sure that you completely freeze it when removing it from the display list.

Since Flash Player 10, if the playhead encounters an empty frame, the display object is automatically frozen even if you did not implement any freezing behavior.

The concept of freezing is also important when loading remote content with the Loader class. When using the Loader class with Flash Player 9, it was necessary to manually freeze content by listening to the Event.UNLOAD event dispatched by the LoaderInfo object. Every object had to be manually frozen, which was a non-trivial task. Flash Player 10 introduced an important new method on the Loader class called unloadAndStop(). This method allows you to unload a SWF file, automatically freeze every object in the loaded SWF file, and force the garbage collector to run.

In the following code, the SWF file is loaded and then unloaded using the unload() method, which requires more processing and manual freezing:

var loader:Loader = new Loader();

loader.load ( new URLRequest ( “content.swf” ) );

addChild ( loader );

stage.addEventListener ( MouseEvent.CLICK, unloadSWF );

function unloadSWF ( e:MouseEvent ):void
{
// Unload the SWF file with no automatic object deactivation
// All deactivation must be processed manually
loader.unload();
}

A best practice is to use the unloadAndStop() method, which handles the freezing natively and forces the garbage
collecting process to run:

var loader:Loader = new Loader();

loader.load ( new URLRequest ( “content.swf” ) );

addChild ( loader );

stage.addEventListener ( MouseEvent.CLICK, unloadSWF );

function unloadSWF ( e:MouseEvent ):void
{
// Unload the SWF file with automatic object deactivation
// All deactivation is handled automatically
loader.unloadAndStop();
}

The following actions occur when the unloadAndStop() method is called:
• Sounds are stopped.
• Listeners registered to the SWF file’s main timeline are removed.
• Timer objects are stopped.
• Hardware peripheral devices (such as camera and microphone) are released.
• Every movie clip is stopped.
• Dispatching of Event.ENTER_FRAME, Event.FRAME_CONSTRUCTED, Event.EXIT_FRAME, Event.ACTIVATE and Event.DEACTIVATE is stopped.

You cannot launch the garbage collector directly in the release version of Flash Player. To make sure that an object is garbage collected, delete all references to the object. Keep in mind that the old delete operator used in ActionScript 1.0 and 2.0 behaves differently in ActionScript 3.0. It can only be used to delete dynamic properties on a dynamic object.

Note: You can call the garbage collector directly in Adobe® AIR® and in the debug version of Flash Player.

For example, the following code sets a Sprite reference to null:

var mySprite:Sprite = new Sprite();

// Set the reference to null, so that the garbage collector removes it from memory
 mySprite = null;

Remember that when an object is set to null, it is not necessarily removed from memory. Sometimes the garbage collector does not run, if available memory is not considered low enough. Garbage collection is not predictable.

Memory allocation, rather than object deletion, triggers garbage collection. When the garbage collector runs, it finds graphs of objects that haven’t been collected yet. It detects inactive objects in the graphs by finding objects that reference each other, but that the application no longer uses. Inactive objects detected this way are deleted.

In large applications, this process can be CPU-intensive and can affect performance and generate a noticeable slowdown in the application. Try to limit garbage collection passes by reusing objects as much as possible.

Also, set references to null, when possible, so that the garbage collector spends less processing time finding the objects. Think of garbage collection as insurance, and always manage object lifetimes explicitly, when possible.

Note: Setting a reference to a display object to null does not ensure that the object is frozen. The object continues consume CPU cycles until it is garbage collected. Make sure that you properly deactivate your object before setting its reference to null.

The garbage collector can be launched using the System.gc() method, available in Adobe AIR and in the debug version of Flash Player. The profiler bundled with Adobe® Flash® Builder™ allows you to start the garbage collector manually. Running the garbage collector allows you to see how your application responds and whether objects are correctly deleted from memory.

Note: If an object was used as an event listener, another object can reference it. If so, remove event listeners using the removeEventListener()method before setting the references to null.

Fortunately, the amount of memory used by bitmaps can be instantly reduced. For example, the BitmapData class includes a dispose() method. The next example creates a BitmapData instance of 1.8 MB. The current memory in use grows to 1.8 MB, and the System.totalMemory property returns a smaller value:

trace(System.totalMemory / 1024);
 // output: 43100

// Create a BitmapData instance
 var image:BitmapData = new BitmapData(800, 600);

trace(System.totalMemory / 1024);
 // output: 44964

Next, the BitmapData is manually removed (disposed) from memory and the memory use is once again checked:

trace(System.totalMemory / 1024);
 // output: 43100

// Create a BitmapData instance
 var image:BitmapData = new BitmapData(800, 600);

trace(System.totalMemory / 1024);
 // output: 44964

image.dispose();
 image = null;

trace(System.totalMemory / 1024);
 // output: 43084

Although the dispose()method removes the pixels from memory, the reference must still be set to null to release it
completely. Always call the dispose() method and set the reference to null when you no longer need a BitmapData
object, so that memory is freed immediately.

Note: Flash Player 10.1 and AIR 1.5.2 introduce a new method called disposeXML() on the System class. This method
allows you to make an XML object immediately available for garbage collection, by passing the XML tree as a parameter.

Another important optimization is called object pooling, which involves reusing objects over time.

You create a defined number of objects during the initialization of your application and store them inside a pool, such as an Array or Vector object. Once you are done with an object, you deactivate it so that it does not consume CPU resources, and
you remove all mutual references.

However, you DO NOT set the references to null, which would make it eligible for garbage collection. You just put the object back into the pool, and retrieve it when you need a new object. Reusing objects reduces the need to instantiate objects, which can be expensive. It also reduces the chances of the garbage collector running, which can slow down your application. The following code illustrates the object pooling technique:

package
 {
 import flash.display.Sprite;

public final class SpritePool
 {
 private static var MAX_VALUE:uint;
 private static var GROWTH_VALUE:uint;
 private static var counter:uint;
 private static var pool:Vector.<Sprite>;
 private static var currentSprite:Sprite;

public static function initialize( maxPoolSize:uint, growthValue:uint ):void
 {
 MAX_VALUE = maxPoolSize;
 GROWTH_VALUE = growthValue;
 counter = maxPoolSize;

var i:uint = maxPoolSize;

pool = new Vector.<Sprite>(MAX_VALUE);
 while( –i > -1 )
 pool[i] = new Sprite();
 }

public static function getSprite():Sprite
 {
 if ( counter > 0 )
 return currentSprite = pool[--counter];

var i:uint = GROWTH_VALUE;
 while( –i > -1 )

pool.unshift ( new Sprite() );
 counter = GROWTH_VALUE;
 return getSprite();
 }

public static function disposeSprite(disposedSprite:Sprite):void
 {
 pool[counter++] = disposedSprite;
 }
 }
 }

The SpritePool class creates a pool of new objects at the initialization of the application.
The getSprite() method returns instances of these objects, and the disposeSprite() method releases them. The code allows the pool to grow when it has been consumed completely. It’s also possible to create a fixed-size pool where new objects would not be allocated when the pool is exhausted. Try to avoid creating new objects in loops, if possible.

The following code uses the SpritePool class to retrieve new instances:

const MAX_SPRITES:uint = 100;
 const GROWTH_VALUE:uint = MAX_SPRITES >> 1;
 const MAX_NUM:uint = 10;

SpritePool.initialize ( MAX_SPRITES,  GROWTH_VALUE );

var currentSprite:Sprite;
 var container:Sprite = SpritePool.getSprite();

addChild ( container );

for ( var i:int = 0; i< MAX_NUM; i++ )
 {
 for ( var j:int = 0; j< MAX_NUM; j++ )
 {
 currentSprite = SpritePool.getSprite();
 currentSprite.graphics.beginFill ( 0×990000 );
 currentSprite.graphics.drawCircle ( 10, 10, 10 );
 currentSprite.x = j * (currentSprite.width + 5);
 currentSprite.y = i * (currentSprite.width + 5);
 container.addChild ( currentSprite );
 }
 }

The following code removes all the display objects from the display list when the mouse is clicked, and reuses them
later for another task:

stage.addEventListener ( MouseEvent.CLICK, removeDots );

function removeDots ( e:MouseEvent ):void
 {
 while (container.numChildren > 0 )
 SpritePool.disposeSprite (container.removeChildAt(0) as Sprite );
 }

Note: The pool vector always references the Sprite objects. If you want to remove the object from memory completely, you
would need a dispose() method on the SpritePool class, which would remove all remaining references.

Another simple way to optimize memory is to reuse objects and avoid recreating them whenever possible.
For example, in a loop, do not use the following code:

const MAX_NUM:int = 18;
 const COLOR:uint = 0xCCCCCC;

var area:Rectangle;

for (var:int = 0; i < MAX_NUM; i++)
 {
 // Do not use the following code
 area = new Rectangle(i,0,1,10);
 myBitmapData.fillRect(area,COLOR);
 }

Recreating the Rectangle object in each loop iteration uses more memory and is slower because a new object is created
in each iteration. Use the following approach:

const MAX_NUM:int = 18;
 const COLOR:uint = 0xCCCCCC;

// Create the rectangle outside the loop
 var area:Rectangle = new Rectangle(0,0,1,10);

for (var:int = 0; i < MAX_NUM; i++)
 {
 area.x = i;
 myBitmapData.fillRect(area,COLOR);
 }

The previous example used an object with a relatively small memory impact. The next example demonstrates larger
memory savings by reusing a BitmapData object. The following code to create a tiling effect wastes memory:

var myImage:BitmapData;
 var myContainer:Bitmap;
 const MAX_NUM:int = 300;

for (var i:int = 0; i< MAX_NUM; i++)
 {

// Create a 20 x 20 pixel bitmap, non-transparent
 myImage = new BitmapData(20,20,false,0xF0D062);

// Create a container for each BitmapData instance
 myContainer = new Bitmap(myImage);

// Add it to the display list
 addChild(myContainer);

// Place each container
 myContainer.x = (myContainer.width + 8 ) * Math.round(i % 20);
myContainer.y = (myContainer.height + 8 ) * int(i / 20);
 }

An optimized version creates a single BitmapData instance referenced by multiple Bitmap instances and produces the same result:

// Create a single 20 x 20 pixel bitmap, non-transparent
 var myImage:BitmapData = new BitmapData(20,20,false,0xF0D062);
 var myContainer:Bitmap;
 const MAX_NUM:int = 300;

for (var i:int = 0; i< MAX_NUM; i++)
 {
 // Create a container referencing the BitmapData instance
 myContainer = new Bitmap(myImage);

// Add it to the display list
 addChild(myContainer);

// Place each container
 myContainer.x = (myContainer.width + 8 ) * Math.round(i % 20);
myContainer.y = (myContainer.height + 8 ) * int(i / 20);
 }

This approach saves about 700 KB in memory, which is a significant savings on a traditional mobile device.

One of the most simple optimization tips to limit memory usage is to use the appropriate type of display object. For simple shapes that are not interactive, use Shape objects. For interactive objects that don’t need a timeline, use Sprite objects. For animation that uses a timeline, use MovieClip objects. Always choose the most efficient type of object for your application.

The following code shows memory usage for different display objects:

 trace(getSize(new Shape()));
 // output: 236

trace(getSize(new Sprite()));
 // output: 412

trace(getSize(new MovieClip()));
 // output: 440

The getSize() method shows how many bytes an object consumes in memory. You can see that using multiple
MovieClip objects instead of simple Shape objects can waste memory if the capabilities of a MovieClip object are not
needed.

resource : RGBLog

In every Actionscript version, when two movieclips (or objects, shapes, texts…) overlap, the one with the greater depth stands in front of the other. You can think about depth as a Z coordinate.

The first difference between AS2 and AS3 is that AS2 allows you to leave “holes” in depths.

For example, you can declare the first object with a depth of 2 and the second one with a depth of 200… no matter if there isn’t any object with a depth between 3 and 199. In AS3, this is no longer possible.

To add an object to the stage, you must use addChild(object_name).
addChild() assigns the first free depth available, just like AS2 MovieClip.getNextHighestDepth()

So let’s add some objects to a movie:

package {
import flash.display.Shape;
import flash.display.Sprite;
public class depths extends Sprite {
public function depths() {
var blue_box:Shape = new Shape();
var red_box:Shape = new Shape();
blue_box.graphics.lineStyle(1);
blue_box.graphics.beginFill(0x0000FF, 1);
blue_box.graphics.drawRect(200,150,100,100);
red_box.graphics.lineStyle(1);
red_box.graphics.beginFill(0xFF0000, 1);
red_box.graphics.drawRect(220,170,100,100);
addChild(blue_box);
addChild(red_box);
}
}
}

This is the result: the red box is in front of the blue box because the red one was the last placed on the screen.

If you switch line 14 with line 15, the blue one will be the one on the top:

Sno now we know that the first child added with addChild() is placed at depth 0, the second one is placed at depth 1, and so on.
To know the depth value of an object, you can use getChildIndex(object_name);. So if you add this line:
trace(getChildIndex(red_box));
You will get a 1 in your output window.
To add an object at a specific depth position, you can use addChildAt(object_name, depth)

So let’s try this code:

package {
import flash.display.Shape;
import flash.display.Sprite;
public class depths extends Sprite {
public function depths() {
var blue_box:Shape = new Shape();
var red_box:Shape = new Shape();
blue_box.graphics.lineStyle(1);
blue_box.graphics.beginFill(0x0000FF, 1);
blue_box.graphics.drawRect(200,150,100,100);
red_box.graphics.lineStyle(1);
red_box.graphics.beginFill(0xFF0000, 1);
red_box.graphics.drawRect(220,170,100,100);
addChild(blue_box);
addChildAt(red_box,0);
}
}
}

Even if the red box was added after the blue box, it’s the blue one to stay on top because the red one was placed at depth zero.

That’s because if the specified depth is already taken by an existing object, then the new object is placed behind the existing one, whose depth is increased by one. So at the end of the script, the red box has depth zero, while the blue one has depth 1
You may ask: what if I change line 14 with addChildAt(blue_box,1);
You can’t… you will get an error because as I said at the beginning of this post, you can’t leave “holes” in depth. So you can’t place an object at depth 1 if there isn’t an object at depth 0.Using getChildIndex in a real life example, you can change line 15 with addChildAt(red_box,getChildIndex(blue_box));And you will get the same result.

Now, let’s see how to change depths dynamically.

package {
import flash.display.Shape;
import flash.display.Sprite;
public class depths extends Sprite {
public function depths() {
var blue_box:Shape = new Shape();
var red_box:Shape = new Shape();
blue_box.graphics.lineStyle(1);
blue_box.graphics.beginFill(0x0000FF, 1);
blue_box.graphics.drawRect(200,150,100,100);
red_box.graphics.lineStyle(1);
red_box.graphics.beginFill(0xFF0000, 1);
red_box.graphics.drawRect(220,170,100,100);
addChild(blue_box);
addChildAt(red_box,getChildIndex(blue_box));
swapChildren(red_box,blue_box);
}
}
}

At line 16 the swapChildren method swaps red box’s depth with the blue box one. So we’ll have the red box in front again

Another way to change depths dynamically is changing line 16 with:

setChildIndex(blue_box,0);

Putting the blue box to depth zero again and make the red one stay on the top of the screen.

data_txt.text = "flashbanneronline.com!";
data_txt.x = 256;
data_txt.y = 145;
data_txt.alpha = 0.3;

Notice how you are repeating the word theContent. A better, cleaner method for referencing one particular object would be to use the with() statement.

The with() statement calls an object once and allows you to access all of the object’s properties and methods with only one reference. For example, using the with() statement, the above lines of code can be written as the following:

with(data_txt)
{

text = "flashbanneronline.com!";
x =256;
y =145;
alpha = 0.3;

}

I refer to data_txt only once! The with() statement may not be versatile enough to carry event handlers, but it does the work of referencing almost any class or object for you.

The following is an example of it working with the top level class Mouse:

with(Mouse)
{

hide();

}

In the above code snippet, I used a top level class and called its hide method.

You can also call nested objects inside the original object. Here is a diagram to better help you visualize what I am referring to:

The code for calling the secondObject object using with() would be:

with(firstObject)
{

secondObject.x = 110;

}

Here, I used a direct path to gain access to the properties of the nested secondObject object.