Maybe your website mochimedia and services that meet you and maybe many games by this code, have seen you play, the method mochimedia emissions are primarily a perloader that, along with a symbol lock is…
Perhaps we were already being protected.

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.

• If a method can be static, declare it static. Speed improvement is by a factor of 4.
• echo is faster than print.(* compare with list from phplens by John Lim)
• Use echo’s multiple parameters instead of string concatenation.
• Set the maxvalue for your for-loops before and not in the loop.
• Unset your variables to free memory, especially large arrays.
• Avoid magic like __get, __set, __autoload
• require_once() is expensive
• Use full paths in includes and requires, less time spent on resolving the OS paths.
• If you need to find out the time when the script started executing, $_SERVER[’REQUEST_TIME’] is preferred to time()
• See if you can use strncasecmp, strpbrk and stripos instead of regex
• str_replace is faster than preg_replace, but strtr is faster than str_replace by a factor of 4
• If the function, such as string replacement function, accepts both arrays and single characters as arguments, and if your argument list is not too long, consider writing a few redundant replacement statements, passing one character at a time, instead of one line of code that accepts arrays as search and replace arguments.
• It’s better to use select statements than multi if, else if, statements.
• Error suppression with @ is very slow.
• Turn on apache’s mod_deflate
• Close your database connections when you’re done with them
• $row[’id’] is 7 times faster than $row[id]
• Error messages are expensive
• Do not use functions inside of for loop, such as for ($x=0; $x < count($array); $x) The count() function gets called each time.
• Incrementing a local variable in a method is the fastest. Nearly the same as calling a local variable in a function.
• Incrementing a global variable is 2 times slow than a local var.
• Incrementing an object property (eg. $this->prop++) is 3 times slower than a local variable.
• Incrementing an undefined local variable is 9-10 times slower than a pre-initialized one.
• Just declaring a global variable without using it in a function also slows things down (by about the same amount as incrementing a local var). PHP probably does a check to see if the global exists.
• Method invocation appears to be independent of the number of methods defined in the class because I added 10 more methods to the test class (before and after the test method) with no change in performance.
• Methods in derived classes run faster than ones defined in the base class.
• A function call with one parameter and an empty function body takes about the same time as doing 7-8 $localvar++ operations. A similar method call is of course about 15 $localvar++ operations.
• Surrounding your string by ‘ instead of ” will make things interpret a little faster since php looks for variables inside “…” but not inside ‘…’. Of course you can only do this when you don’t need to have variables in the string.
• When echoing strings it’s faster to separate them by comma instead of dot. Note: This only works with echo, which is a function that can take several strings as arguments.
• A PHP script will be served at least 2-10 times slower than a static HTML page by Apache. Try to use more static HTML pages and fewer scripts.
• Your PHP scripts are recompiled every time unless the scripts are cached. Install a PHP caching product to typically increase performance by 25-100% by removing compile times.
• Cache as much as possible. Use memcached – memcached is a high-performance memory object caching system intended to speed up dynamic web applications by alleviating database load. OP code caches are useful so that your script does not have to be compiled on every request
• When working with strings and you need to check that the string is either of a certain length you’d understandably would want to use the strlen() function. This function is pretty quick since it’s operation does not perform any calculation but merely return the already known length of a string available in the zval structure (internal C struct used to store variables in PHP). However because strlen() is a function it is still somewhat slow because the function call requires several operations such as lowercase & hashtable lookup followed by the execution of said function. In some instance you can improve the speed of your code by using an isset() trick.

Ex.

if (strlen($foo) < 5) { echo "Foo is too short"; }

vs.

if (!isset($foo{5})) { echo "Foo is too short"; }

• Calling isset() happens to be faster then strlen() because unlike strlen(), isset() is a language construct and not a function meaning that it’s execution does not require function lookups and lowercase. This means you have virtually no overhead on top of the actual code that determines the string’s length.
• When incrementing or decrementing the value of the variable $i++ happens to be a tad slower then ++$i. This is something PHP specific and does not apply to other languages, so don’t go modifying your C or Java code thinking it’ll suddenly become faster, it won’t. ++$i happens to be faster in PHP because instead of 4 opcodes used for $i++ you only need 3. Post incrementation actually causes in the creation of a temporary var that is then incremented. While pre-incrementation increases the original value directly. This is one of the optimization that opcode optimized like Zend’s PHP optimizer. It is a still a good idea to keep in mind since not all opcode optimizers perform this optimization and there are plenty of ISPs and servers running without an opcode optimizer.
• Not everything has to be OOP, often it is too much overhead, each method and object call consumes a lot of memory.
• Do not implement every data structure as a class, arrays are useful, too
• Don’t split methods too much, think, which code you will really re-use
• You can always split the code of a method later, when needed
• Make use of the countless predefined functions
• If you have very time consuming functions in your code, consider writing them as C extensions
• Profile your code. A profiler shows you, which parts of your code consumes how many time. The Xdebug debugger already contains a profiler. Profiling shows you the bottlenecks in overview
• mod_gzip which is available as an Apache module compresses your data on the fly and can reduce the data to transfer up to 80%
• Excellent Article about optimizing php by John Lim

As Reihold Webber pointed to a post from John Lim (found this article copied without state the source here), then i investigate further and truly that is an excellent best practice tutorial for optimizing the php code performance, covered almost all aspects from low level webserver configuration, PHP configuration, coding styling, and performace comparisson as well.

Another good practice for better php performance as written in cluesheet.com are:

• Do use single quotes over double quotes.
• Do use switch over lots of if statements
• Do avoid testing loop conditionals with function tests every iteration eg. for($i=0;i<=count($x);$i++){…
• Do use foreach for looping collections/arrays. PHP4 items are byval, greater than PHP5 items are byref
• Do consider using the Singleton Method when creating complex PHP classes.
• Do use POST over GET for all values that will wind up in the database for TCP/IP packet performance reasons.
• Do use ctype_alnum,ctype_alpha and ctype_digit over regular expression to test form value types for performance reasons.
• Do use full file paths in production environment over basename/fileexists/open_basedir to avoid performance hits for the filesystem having to hunt through the file path. Once determined, serialize and/or cache path values in a $_SETTINGS array. $_SETTINGS["cwd"]=cwd(./);
• Do use require/include over require_once/include_once to ensure proper opcode caching.
• Do use tmpfile or tempnam for creating temp files/filenames
• Do use a proxy to access web services (XML or JSOM) on foreign domains using XMLHTTP to avoid cross-domain errors. eg. foo.com<–>XMLHTTP<–>bar.com
• Do use error_reporting (E_ALL); during debug.
• Do set Apache allowoverride to “none” to improve Apache performance in accessing files/directories.
• Do use a fast fileserver for serving static content (thttpd). static.mydomain.com, dynamic.mydomain.com
• Do serialize application settings like paths into an associative array and cache or serialize that array after first execution.
• Do use PHP output control buffering for page caching of heavilty accessed pages
• Do use PDO prepare over native db prepare for statements. mysql_attr_direct_query=>1
• Do NOT use SQL wildcard select. eg. SELECT *
• Do use database logic (queries, joins, views, procedures) over loopy PHP.
• Do use shortcut syntax for SQL insers if not using PDO parameters parameters. eg. INSERT INTO MYTABLE (FIELD1,FIELD2) VALUES ((“x”,”y”),(“p”,”q”));

Another Interesting articles about optimizing php performance:

• PHP & Mysql Cache Performance Comparison
• Accelerating PHP Applications Slide presentation International PHP Conference 2004
• Caching output in PHP

source

Everything that has an instance name,is an Object. Each object inherits the properties and methods of its class. The Class is basically the “prototype” of an Object,and as such,you can have as many objects as you want from a single class.

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 optimization is becoming increasing important & with alternative development tools that developers can use. We all have a responsibility to build Flash elements that are efficient as much as they are groundbreaking. As someone who feels responsible for the future of this great application, I am creating a Flash Optimization series that will help educate the Flash development community on how to keep their Flash elements as lean as possible.

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.

Flash optimization is becoming increasing important & with alternative development tools that developers can use. We all have a responsibility to build Flash elements that are efficient as much as they are groundbreaking. As someone who feels responsible for the future of this great application, I am creating a Flash Optimization series that will help educate the Flash development community on how to keep their Flash elements as lean as possible.

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.

Flash optimization is becoming increasing important & with alternative development tools that developers can use. We all have a responsibility to build Flash elements that are efficient as much as they are groundbreaking. As someone who feels responsible for the future of this great application, I am creating a Flash Optimization series that will help educate the Flash development community on how to keep their Flash elements as lean as possible.

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.

Flash optimization is becoming increasing important & with alternative development tools that developers can use. We all have a responsibility to build Flash elements that are efficient as much as they are groundbreaking. As someone who feels responsible for the future of this great application, I am creating a Flash Optimization series that will help educate the Flash development community on how to keep their Flash elements as lean as possible.

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.

Total primary goal , to create a tool with a different environment of the software available for more enjoyable to follow site information is complete and current version of growth and achieve sufficient as a tool for the complete facility Find and follow RSS feeds will , give your loved ones will be .

The current version of the program , the following features will provide you :
1 – View headlines last this blog content ( in future versions of supplemental feed Add the desired user can be created )
2 – Find a brief description in relation to content
3 – Settings related to the time information from server Refresh
4 – Settings related to the pause interval between each display
5 – Save the Last Data Feed and performance if being offline
And …

Images of the Environment Program :

Download :

Must install Adobe AIR is installed on your system.

Adobe Air format

ِDownload FlashBannerOnline RSS Reader (air format)

Adobe Air EXE format

ِDownload FlashBannerOnline RSS Reader (exe format)

Note :
To run on Windows 7 is better , right click on the program and click Run as administrator option to run the program .

Changes made in new versions

Version 1.1
Stop rotating display at the content display mouse button and box description , was added .

Version 1.0
First version created .
Bug :
If the problem or error in the program can be seen in the same comment more bug fixes and improvements to my program tell (with this post comment )

the Persian Language of this software update Here.

Flash optimization is becoming increasing important & with alternative development tools that developers can use. We all have a responsibility to build Flash elements that are efficient as much as they are groundbreaking. As someone who feels responsible for the future of this great application, I am creating a Flash Optimization series that will help educate the Flash development community on how to keep their Flash elements as lean as possible.

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.