Section 1
//Removable (basic.Removable)
package basic {
	import flash.display.*;

	public class Removable extends Sprite {

		private var removed:Boolean;// = false

		function removeChildren(doc:DisplayObjectContainer):void{
			var child:DisplayObject;
			var newDOC:DisplayObjectContainer;
			while (doc.numChildren > 0) {
				child = doc.getChildAt(0);
				if ((child is DisplayObjectContainer)){
					newDOC = DisplayObjectContainer(child);
					removeChildren(newDOC);
				};
				doc.removeChild(child);
			};
		}
		public function remove():void{
			if (!removed){
				removed = true;
				if (parent != null){
					parent.removeChild(this);
				};
			} else {
				trace("Error: this has already been removed.");
			};
		}

	}
}//package basic 
Section 2
//Data (data.Data)
package data {
	import flash.display.*;
	import flash.utils.*;

	public class Data {

		private static var stage:Stage;

		public static function commify(num:Number):String{
			var a:* = [];
			while (num > 0) {
				a.push((num % 1000));
				num = Math.floor((num / 1000));
			};
			return (a.reverse().join(","));
		}
		public static function arrayRandom(array:Array){
			var len:int = array.length;
			var i:int = Math.floor((Math.random() * len));
			var val:* = array[i];
			return (val);
		}
		public static function formatTime(seconds:int):String{
			var minutes:Number = Math.floor((seconds / 60));
			var remainingSec:Number = (seconds % 60);
			var stringSeconds:String = remainingSec.toString();
			if (stringSeconds.length < 2){
				stringSeconds = ("0" + stringSeconds);
			};
			var ret:String = ((minutes + ":") + stringSeconds);
			return (ret);
		}
		public static function allowedURL(allowedArray:Array, allowLocal:Boolean=false):Boolean{
			var domain:String;
			var doubleSlash:Number;
			var i:int;
			var len:int;
			var allowedDomain:String;
			var ret:Boolean;
			var stage:Stage = Data.getStage();
			var url:String = stage.loaderInfo.url;
			var protocol:String = url.substr(0, url.indexOf(":"));
			if (protocol == "file"){
				domain = "local";
				if (allowLocal){
					ret = true;
				};
			} else {
				if (protocol == "http"){
					doubleSlash = url.indexOf("//");
					domain = url.substr((doubleSlash + 2), ((url.indexOf("/", (doubleSlash + 2)) - doubleSlash) - 2));
					domain = domain.toLowerCase();
					if (domain.indexOf("www.") != -1){
						domain = domain.substr((domain.indexOf("www.") + 4), domain.length);
					};
					trace(("domain: " + domain));
					len = allowedArray.length;
					i = 0;
					while (i < len) {
						allowedDomain = allowedArray[i];
						if (domain.indexOf(allowedDomain) != -1){
							ret = true;
							break;
						};
						i++;
					};
				};
			};
			return (ret);
		}
		public static function getStage():Stage{
			if (stage == null){
				stage = BaseClass.instance.stage;
			};
			return (stage);
		}
		public static function stringToObject(string:String){
			var ClassReference:Class = (getDefinitionByName(string) as Class);
			var ret:* = new (ClassReference);
			return (ret);
		}
		public static function getMS():int{
			var date:Date = new Date();
			var ms:int = date.time;
			return (ms);
		}

	}
}//package data 
Section 3
//Maths (data.Maths)
package data {

	public class Maths {

		public static var RAD_DEG:Number = 57.2957795130823;
		public static var DEG_RAD:Number = 0.0174532925199433;

		public static function rand(min:Number, max:Number, round:int=0):Number{
			var dif:Number = (max - min);
			var rand:Number = (Math.random() * dif);
			rand = (rand + min);
			var str:String = rand.toFixed(round);
			var ret:Number = Number(str);
			return (ret);
		}
		public static function getShortestRotChange(deg1:Number, deg2:Number):Number{
			var rotChange:* = (deg1 - deg2);
			var rotChange2:* = ((rotChange - 360) % 360);
			var rotChange3:* = ((rotChange + 360) % 360);
			if (Math.abs(rotChange2) < Math.abs(rotChange)){
				rotChange = rotChange2;
			};
			if (Math.abs(rotChange3) < Math.abs(rotChange)){
				rotChange = rotChange3;
			};
			return (rotChange);
		}
		public static function pythag(xDist:Number, yDist:Number):Number{
			return (Math.sqrt(((xDist * xDist) + (yDist * yDist))));
		}
		public static function limit(num:Number, min:Number, max:Number):Number{
			if (num > max){
				num = max;
			};
			if (num < min){
				num = min;
			};
			return (num);
		}

	}
}//package data 
Section 4
//Stats (data.Stats)
package data {
	import flash.display.*;
	import flash.events.*;
	import flash.utils.*;
	import flash.system.*;

	public class Stats extends Sprite {

		private var frameCount:Number;// = 0
		private var secondInterval:uint;

		public static var mem:Number = 0;
		public static var fps:Number = 0;
		private static var instance:Stats;

		public function Stats():void{
			super();
			secondInterval = setInterval(calcStats, 1000);
			addEventListener(Event.ENTER_FRAME, incFrameCount, false, 0, true);
		}
		private function incFrameCount(e:Event){
			frameCount++;
		}
		private function calcStats():void{
			Stats.fps = frameCount;
			Stats.mem = ((System.totalMemory / 0x0400) / 0x0400);
			frameCount = 0;
		}
		private function remove():void{
			clearInterval(secondInterval);
			removeEventListener(Event.ENTER_FRAME, incFrameCount);
		}

		public static function start():void{
			stop();
			instance = new (Stats);
		}
		public static function stop():void{
			if (instance != null){
				instance.remove();
				instance = null;
			};
		}

	}
}//package data 
Section 5
//ag_intro_mc_75 (EffingHail_fla.ag_intro_mc_75)
package EffingHail_fla {
	import flash.display.*;

	public dynamic class ag_intro_mc_75 extends MovieClip {

		public function ag_intro_mc_75(){
			addFrameScript(0, frame1, 217, frame218);
		}
		function frame218(){
			MovieClip(parent).play();
		}
		function frame1(){
			gotoAndPlay(2);
		}

	}
}//package EffingHail_fla 
Section 6
//explosionAnim_9 (EffingHail_fla.explosionAnim_9)
package EffingHail_fla {
	import flash.display.*;

	public dynamic class explosionAnim_9 extends MovieClip {

		public function explosionAnim_9(){
			addFrameScript(7, frame8);
		}
		function frame8(){
			stop();
		}

	}
}//package EffingHail_fla 
Section 7
//lessonAnim_51 (EffingHail_fla.lessonAnim_51)
package EffingHail_fla {
	import flash.display.*;

	public dynamic class lessonAnim_51 extends MovieClip {

		public var anim:MovieClip;

		public function lessonAnim_51(){
			addFrameScript(120, frame121);
		}
		function frame121(){
			stop();
		}

	}
}//package EffingHail_fla 
Section 8
//MainTimeline (EffingHail_fla.MainTimeline)
package EffingHail_fla {
	import flash.display.*;
	import preloader.*;

	public dynamic class MainTimeline extends MovieClip {

		public var base:BaseClass;

		public function MainTimeline(){
			addFrameScript(0, frame1, 2, frame3, 4, frame5);
		}
		function frame1(){
			stop();
			addChild(new Preloader(root));
		}
		function frame3(){
			stop();
			base = new BaseClass();
			addChild(base);
			base.init();
		}
		function frame5(){
			gotoAndStop(4);
		}

	}
}//package EffingHail_fla 
Section 9
//pageFlipAnimation_56 (EffingHail_fla.pageFlipAnimation_56)
package EffingHail_fla {
	import flash.display.*;

	public dynamic class pageFlipAnimation_56 extends MovieClip {

		public function pageFlipAnimation_56(){
			addFrameScript(25, frame26);
		}
		function frame26(){
			stop();
		}

	}
}//package EffingHail_fla 
Section 10
//Baloon (game.things.Baloon)
package game.things {
	import flash.events.*;
	import game.*;
	import data.*;

	public class Baloon extends MoveThing {

		private var maxY:Number;// = 640
		private var minY:Number;// = 250
		private var velY:Number;// = 1

		public function Baloon():void{
			super();
			prependString = "Baloon";
			setState("float");
			life = 25;
			velY = Maths.rand(0.1, 1, 9);
			velX = Maths.rand(-0.1, 0.1, 9);
			minX = 117;
			maxX = (BaseClass.width - 71);
			sortOrder = 4;
		}
		override protected function die():void{
			GamePage.instance.killBaloon();
			super.die();
		}
		override protected function go(e:Event):void{
			y = (y + velY);
			if (y > maxY){
				y = maxY;
				velY = (velY * -1);
			};
			if (y < minY){
				y = minY;
				velY = (velY * -1);
			};
			super.go(e);
		}

	}
}//package game.things 
Section 11
//Building (game.things.Building)
package game.things {
	import game.*;

	public class Building extends Thing {

		public function Building():void{
			super();
			prependString = "Building";
			setState("stand");
			life = 150;
			sortOrder = 0;
		}
		override protected function die():void{
			GamePage.instance.killBuilding();
			super.die();
		}

	}
}//package game.things 
Section 12
//House (game.things.House)
package game.things {
	import game.*;

	public class House extends Thing {

		public function House():void{
			super();
			prependString = "House";
			setState("stand");
			life = 50;
			sortOrder = 1;
		}
		override protected function die():void{
			GamePage.instance.killHouse();
			super.die();
		}

	}
}//package game.things 
Section 13
//MoveThing (game.things.MoveThing)
package game.things {
	import flash.events.*;
	import data.*;

	public class MoveThing extends Thing {

		protected var maxX;
		protected var minX;// = 100
		protected var velX:Number;

		public function MoveThing():void{
			maxX = BaseClass.width;
			super();
			addEventListener(Event.ENTER_FRAME, go, false, 0, true);
			velX = Maths.rand(-3, 3, 9);
			if (Math.abs(velX) < 1){
				velX = 1;
			};
		}
		override protected function die():void{
			removeEventListener(Event.ENTER_FRAME, go);
			super.die();
		}
		protected function checkWalls():void{
			if (x > maxX){
				x = maxX;
				velX = (velX * -1);
			};
			if (x < minX){
				x = minX;
				velX = (velX * -1);
			};
		}
		protected function getRandVel(max:Number):void{
			var vel:Number = ((Math.random() * (max * 2)) - max);
		}
		override public function remove():void{
			removeEventListener(Event.ENTER_FRAME, go);
			super.remove();
		}
		protected function go(e:Event):void{
			x = (x + velX);
			checkWalls();
		}

	}
}//package game.things 
Section 14
//Person (game.things.Person)
package game.things {
	import game.*;

	public class Person extends MoveThing {

		public function Person():void{
			super();
			prependString = "Person";
			setState("walk");
			life = 15;
			velX = (velX * 0.25);
			minX = 135;
			maxX = 560;
			sortOrder = 3;
		}
		override protected function die():void{
			GamePage.instance.killPerson();
			super.die();
		}

	}
}//package game.things 
Section 15
//Plane (game.things.Plane)
package game.things {
	import flash.events.*;
	import game.*;

	public class Plane extends MoveThing {

		public function Plane():void{
			super();
			prependString = "Plane";
			setState("fly");
			minX = 0;
			maxX = (BaseClass.width + 100);
			life = 150;
			sortOrder = 5;
		}
		override protected function go(e:Event):void{
			super.go(e);
			if (velX < 0){
				scaleX = -1;
			} else {
				scaleX = 1;
			};
		}
		override protected function die():void{
			GamePage.instance.killPlane();
			super.die();
		}

	}
}//package game.things 
Section 16
//Satellite (game.things.Satellite)
package game.things {
	import game.*;

	public class Satellite extends MoveThing {

		public function Satellite():void{
			super();
			prependString = "Satellite";
			setState("float");
			life = 75;
			sortOrder = 6;
			minX = 0;
			maxX = (BaseClass.width + 100);
		}
		override protected function die():void{
			GamePage.instance.killSatellite();
			super.die();
		}
		override protected function checkWalls():void{
			if (x < minX){
				x = maxX;
			};
			if (x > maxX){
				x = minX;
			};
		}

	}
}//package game.things 
Section 17
//Thing (game.things.Thing)
package game.things {
	import flash.events.*;
	import stateObjects.*;

	public class Thing extends StateObject {

		public var sortOrder:int;// = 0
		public var dead:Boolean;// = false
		protected var life:Number;// = 100

		public function Thing():void{
			super();
			alpha = 0;
			addEventListener(Event.ENTER_FRAME, fadeIn, false, 0, true);
		}
		private function fadeIn(e:Event):void{
			alpha = (alpha + 0.02);
			if (alpha >= 1){
				alpha = 1;
				removeEventListener(Event.ENTER_FRAME, fadeIn);
			};
		}
		protected function die():void{
			dead = true;
			setState("die");
		}
		private function fadeOut(e:Event):void{
			alpha = (alpha - 0.01);
			if (alpha <= 0){
				remove();
			};
		}
		override public function remove():void{
			removeEventListener(Event.ENTER_FRAME, fadeOut);
			removeEventListener(Event.ENTER_FRAME, fadeIn);
			super.remove();
		}
		public function getHit(damage:Number):void{
			life = (life - damage);
			if (life <= 0){
				die();
				removeEventListener(Event.ENTER_FRAME, fadeOut);
				addEventListener(Event.ENTER_FRAME, fadeOut, false, 0, true);
			};
		}

	}
}//package game.things 
Section 18
//GamePage (game.GamePage)
package game {
	import flash.media.*;
	import flash.display.*;
	import flash.events.*;
	import page.*;
	import sounds.*;
	import data.*;
	import menu.*;
	import game.things.*;
	import flash.utils.*;

	public class GamePage extends Page {

		private var planesKilled:int;// = 0
		private var wind:WindGraphic;
		private var people:int;// = 0
		private var homesKilled:int;// = 0
		private var score:int;// = 0
		private var planes:int;// = 0
		private var satellites:int;// = 0
		private var buildingsKilled:int;// = 0
		private var timerInterval:uint;
		private var baloons:int;// = 0
		private var satellitesKilled:int;// = 0
		private var lesson:int;// = 0
		private var personInterval:uint;
		private var mousePressed:Boolean;// = false
		private var buildings:int;// = 0
		private var hailInterval:uint;
		private var baloonsKilled:int;// = 0
		private var windChannel:SoundChannel;
		private var planeTimeout:uint;
		private var fps:int;// = 30
		private var peopleKilled:int;// = 0
		private var m:GamePageGraphic;
		private var homes:int;// = 0
		private var seconds:int;// = 60

		public static var instance:GamePage;

		public function GamePage(lesson:int=1):void{
			super();
			GamePage.instance = this;
			timerInterval = setInterval(runTimer, 1000);
			hailInterval = setInterval(createHail, 45);
			addEventListener(Event.ENTER_FRAME, go, false, 0, true);
			BaseClass.instance.stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler, false, 0, true);
			BaseClass.instance.stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, false, 0, true);
			BaseClass.instance.stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler, false, 0, true);
			m = new GamePageGraphic();
			addChild(m);
			wind = new WindGraphic();
			m.addChild(wind);
			this.lesson = (lesson - 1);
			nextLesson();
			Music.startMusic(new GameSong());
			Music.setVolume(0);
			Music.startGlideToVolume(0.75, 3);
		}
		private function runTimer():void{
			seconds--;
			m.timeBox.text = Data.formatTime(seconds);
			if ((((((seconds >= 0)) && ((seconds < 5)))) || ((seconds == 10)))){
				Sounds.startSound(new Beep1Sound(), 0.5);
			};
			if (seconds < 0){
				Sounds.startSound(new Beep2Sound(), 0.75);
				BaseClass.instance.setPage(new SubmitPage(lesson, score, satellitesKilled, baloonsKilled, planesKilled, buildingsKilled, homesKilled, peopleKilled));
			};
		}
		override public function remove():void{
			var hail:Hail;
			var thing:Thing;
			while (m.hailHolder.numChildren > 0) {
				hail = Hail(m.hailHolder.getChildAt(0));
				hail.remove();
			};
			while (m.thingHolder.numChildren > 0) {
				thing = Thing(m.thingHolder.getChildAt(0));
				thing.remove();
			};
			clearInterval(timerInterval);
			clearInterval(hailInterval);
			clearInterval(personInterval);
			clearTimeout(planeTimeout);
			removeEventListener(Event.ENTER_FRAME, go);
			BaseClass.instance.stage.removeEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
			BaseClass.instance.stage.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
			BaseClass.instance.stage.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
			removeChild(m);
			m = null;
			stopWindSound();
			GamePage.instance = null;
			super.remove();
		}
		private function mouseUpHandler(me:MouseEvent):void{
			mousePressed = false;
			wind.gotoAndStop("off");
			stopWindSound();
		}
		private function nextLesson():void{
			var title:String;
			lesson++;
			if (lesson == 1){
				createHomes(1);
				title = "Lesson One: Smash the house.";
			};
			if (lesson == 2){
				createBuildings(2);
				title = "Lesson Two: Destroy the skyscrapers!";
			};
			if (lesson == 3){
				createPlanes(1);
				title = "Lesson Three: Bring down the plane!";
			};
			if (lesson == 4){
				createSatellites(2);
				title = "Lesson Four: Battle the spy satellites!";
			};
			if (lesson == 5){
				createPeople(5);
				title = "Lesson Five: Vanquish the pedestrians!";
			};
			if (lesson == 6){
				createPlanes(1);
				createBaloons(8);
				title = "Lesson Six: Pop the weather baloons!";
			};
			if (lesson == 7){
				createPlanes(1);
				createSatellites(2);
				createBaloons(2);
				title = "Lesson Seven: Bring icy doom to all!";
			};
			if (lesson == 8){
				createPlanes(1);
				createSatellites(2);
				createBaloons(2);
				createBuildings(3);
				createHomes(6);
				createPeople(3);
				title = "You won! Rack up the points!";
			};
			if ((((((lesson == 3)) || ((lesson == 4)))) || ((lesson >= 6)))){
				if (homes <= 0){
					createHomes(3);
				};
				if (buildings <= 0){
					createBuildings(2);
				};
			};
			if (lesson > 1){
				m.instructions.visible = false;
			};
			m.lessonAnim.anim.textBox.text = title;
			m.lessonAnim.gotoAndPlay("appear");
			seconds = (seconds + 45);
			if (lesson != 1){
				Sounds.startSound(new ApplauseSound());
			};
		}
		private function stopWindSound():void{
			if (windChannel != null){
				windChannel.stop();
			};
			windChannel = null;
		}
		public function hit(hitX:Number, hitY:Number, power:int):Boolean{
			var damage:int;
			var things:int;
			var i:int;
			var thing:Thing;
			var explosion:ExplosionGraphic;
			var volume:Number;
			var ret:Boolean;
			if (hitY > 640){
				ret = true;
			} else {
				if (m.thingHolder.hitTestPoint(hitX, hitY, true)){
					damage = ((power / 50) - 4);
					if (damage > 0){
						things = m.thingHolder.numChildren;
						i = 0;
						while (i < things) {
							thing = Thing(m.thingHolder.getChildAt(i));
							if (((thing.hitTestPoint(hitX, hitY, true)) && (!(thing.dead)))){
								ret = true;
								thing.getHit(damage);
								incScore(damage);
								explosion = new ExplosionGraphic();
								explosion.x = hitX;
								explosion.y = hitY;
								explosion.text.textBox.text = damage.toString();
								explosion.anim.scaleX = (explosion.anim.scaleY = (damage / 25));
								addChild(explosion);
								break;
							};
							i++;
						};
					} else {
						ret = true;
					};
				};
			};
			if (((ret) && ((power > 500)))){
				volume = (power / 1250);
				volume = Maths.limit(volume, 0, 3);
				Sounds.startSound(new ExplosionSound(), volume);
			};
			return (ret);
		}
		private function createBaloons(baloons:int):void{
			var baloon:Baloon;
			this.baloons = baloons;
			var i:int = baloons;
			while (i > 0) {
				baloon = new Baloon();
				baloon.x = (Math.random() * BaseClass.width);
				baloon.y = 640;
				m.thingHolder.addChild(baloon);
				i--;
			};
			sortDepth();
		}
		public function addHail(hail:Hail):void{
			m.hailHolder.addChild(hail);
		}
		private function createBuildings(buildings:int):void{
			var building:Building;
			this.buildings = buildings;
			var minX:Number = 250;
			var maxX:Number = 525;
			var array:Array = new Array();
			var i:int = buildings;
			while (i > 0) {
				building = new Building();
				building.scaleX = (building.scaleY = ((Math.random() * 0.35) + 0.65));
				building.y = (630 - (Math.random() * 10));
				array.push(building);
				m.thingHolder.addChild(building);
				i--;
			};
			spaceEvenly(array, minX, maxX);
			sortDepth();
		}
		private function createPeople(people:int):void{
			var person:Person;
			this.people = people;
			var i:int = people;
			while (i > 0) {
				person = new Person();
				person.x = Maths.rand(135, 560);
				person.y = 645;
				m.thingHolder.addChild(person);
				i--;
			};
			sortDepth();
		}
		private function startWindSound():void{
			stopWindSound();
			windChannel = Sounds.startSound(new WindSound(), 0.25, 0, 999);
		}
		public function killPlane():void{
			planes--;
			planesKilled++;
			incScore(500);
			if (planes <= 0){
				if (lesson == 3){
					nextLesson();
				};
			};
			checkEndGame();
		}
		private function createSatellites(num:int):void{
			var sat:Satellite;
			this.satellites = num;
			var i:int = num;
			while (i > 0) {
				sat = new Satellite();
				sat.y = (100 + (Math.random() * 50));
				m.thingHolder.addChild(sat);
				i--;
			};
			sortDepth();
		}
		public function killBuilding():void{
			buildings--;
			buildingsKilled++;
			incScore(100);
			if (buildings <= 0){
				if (((!((lesson == 5))) && (!((lesson == 7))))){
					buildings = Maths.rand(1, 3);
					createBuildings(buildings);
				};
				if (lesson == 2){
					nextLesson();
				};
			};
			checkEndGame();
		}
		private function createPlanes(num:int):void{
			var plane:Plane;
			this.planes = num;
			var i:int = num;
			while (i > 0) {
				plane = new Plane();
				plane.x = Maths.rand(100, (BaseClass.width - 100));
				plane.y = 400;
				m.thingHolder.addChild(plane);
				i--;
			};
			sortDepth();
		}
		private function checkEndGame():void{
			if ((((((((((((((lesson == 7)) && ((satellites <= 0)))) && ((baloons <= 0)))) && ((planes <= 0)))) && ((buildings <= 0)))) && ((homes <= 0)))) && ((people <= 0)))){
				nextLesson();
			};
		}
		private function sortDepth():void{
			var i:int;
			var array:Array = new Array();
			var num:int = m.thingHolder.numChildren;
			i = 0;
			while (i < num) {
				array[i] = m.thingHolder.getChildAt(i);
				i++;
			};
			array = array.sortOn("sortOrder");
			i = 0;
			while (i < num) {
				m.thingHolder.addChildAt(array[i], i);
				i++;
			};
		}
		private function spaceEvenly(array:Array, minX:int, maxX:int):void{
			var i:int;
			var obj:DisplayObject;
			var dist:int = (maxX - minX);
			var space:Number = (dist / array.length);
			var curX:Number = minX;
			var len:int = array.length;
			i = 0;
			while (i < len) {
				obj = array[i];
				obj.x = curX;
				obj.x = (obj.x + Maths.rand((obj.width / 2), (space - (obj.width / 2)), 9));
				curX = (curX + space);
				i++;
			};
		}
		public function killPerson():void{
			people--;
			peopleKilled++;
			incScore(50);
			if (people <= 0){
				if (lesson != 7){
					people = Maths.rand(1, 5);
					createPeople(people);
				};
				if (lesson == 5){
					nextLesson();
				};
			};
			checkEndGame();
		}
		public function killBaloon():void{
			baloons--;
			baloonsKilled++;
			incScore(75);
			if (baloons <= 0){
				if (lesson == 6){
					nextLesson();
				};
			};
			checkEndGame();
		}
		public function killHouse():void{
			homes--;
			homesKilled++;
			incScore(50);
			if (homes <= 0){
				if (((!((lesson == 5))) && (!((lesson == 7))))){
					homes = Maths.rand(2, 6);
					createHomes(homes);
				};
				if (lesson == 1){
					nextLesson();
				};
			};
			checkEndGame();
		}
		public function incScore(inc:int):void{
			score = (score + inc);
			m.scoreBox.text = ("$" + Data.commify(score));
		}
		private function createHomes(homes:int):void{
			var house:House;
			this.homes = homes;
			var minX:Number = 175;
			var maxX:Number = 560;
			var array:Array = new Array();
			var i:int = homes;
			while (i > 0) {
				house = new House();
				house.y = (640 - (Math.random() * 10));
				house.scaleX = (house.scaleY = ((Math.random() * 0.35) + 0.65));
				array.push(house);
				m.thingHolder.addChild(house);
				i--;
			};
			spaceEvenly(array, minX, maxX);
			sortDepth();
		}
		private function mouseDownHandler(me:MouseEvent):void{
			mousePressed = true;
			wind.gotoAndStop("on");
			startWindSound();
		}
		private function mouseMoveHandler(me:MouseEvent):void{
			wind.x = me.stageX;
			wind.y = me.stageY;
		}
		private function go(e:Event):void{
			var range:Number;
			var power:Number;
			var hailNum:int;
			var i:int;
			var hail:Hail;
			var distX:Number;
			var distY:Number;
			var dist:Number;
			var ratio:Number;
			var gust:Number;
			var rad:Number;
			var gustX:Number;
			var gustY:Number;
			if (mousePressed){
				range = 100;
				power = 3;
				hailNum = m.hailHolder.numChildren;
				i = 0;
				while (i < hailNum) {
					hail = Hail(m.hailHolder.getChildAt(i));
					distX = (hail.x - mouseX);
					distY = (hail.y - mouseY);
					dist = Maths.pythag(distX, distY);
					if (dist < range){
						ratio = ((range - dist) / range);
						gust = (power * ratio);
						rad = Math.atan2(distY, distX);
						gustX = (Math.cos(rad) * gust);
						gustY = (Math.sin(rad) * gust);
						hail.gust(gustX, gustY);
					};
					i++;
				};
			};
		}
		private function createHail():void{
			var posX:Number;
			var posY:Number;
			var hail:Hail;
			var lag:Number = (Stats.fps / fps);
			if (lag > Math.random()){
				posX = ((Math.random() * (BaseClass.width - 100)) + 100);
				posY = (Math.random() * 150);
				hail = new Hail(posX, posY);
				addHail(hail);
			};
			sortDepth();
		}
		public function killSatellite():void{
			satellites--;
			satellitesKilled++;
			incScore(500);
			if (satellites <= 0){
				if (lesson == 4){
					nextLesson();
				};
			};
			checkEndGame();
		}

	}
}//package game 
Section 19
//Hail (game.Hail)
package game {
	import flash.events.*;
	import data.*;
	import basic.*;

	public class Hail extends Removable {

		private var size:int;// = 1
		private var minX:Number;// = 90
		private var gravity:Number;// = 0.11
		private var velX:Number;
		private var velY:Number;
		private var invincible:int;
		private var growCounterReset:int;// = 20
		private var growCounter:int;// = 0
		private var m:HailGraphic;
		private var rotSpeed:Number;// = 0
		private var maxX:Number;

		public function Hail(x:Number, y:Number, velX:Number=0, velY:Number=4, size:int=1, invincible:int=0):void{
			maxX = (BaseClass.width + 10);
			super();
			this.x = x;
			this.y = y;
			this.velX = velX;
			this.velY = velY;
			this.size = size;
			this.invincible = invincible;
			rotSpeed = ((Math.random() * 20) - 10);
			addEventListener(Event.ENTER_FRAME, go, false, 0, true);
			m = new HailGraphic();
			addChild(m);
			setSize(size);
		}
		private function setSize(size:int):void{
			this.size = size;
			scaleX = (scaleY = ((size * 0.01) + 0.01));
			if (size >= 15){
				m.sizeMeasure.visible = true;
			} else {
				m.sizeMeasure.visible = false;
			};
		}
		override public function remove():void{
			removeEventListener(Event.ENTER_FRAME, go);
			super.remove();
		}
		public function gust(gustX:Number, gustY:Number):void{
			if (size <= 0){
				size = 1;
			};
			velX = (velX + (gustX / Math.sqrt((size + 4))));
			velY = (velY + (gustY / Math.sqrt((size + 4))));
		}
		public function hitSomething():void{
			var pieceNum:int;
			var pieceSize:int;
			var i:int;
			var velX:Number;
			var velY:Number;
			var piece:Hail;
			if (size > 9){
				pieceNum = 3;
				pieceSize = (size / 2);
				if (pieceSize >= 2){
					i = 0;
					while (i < pieceNum) {
						velX = ((Math.random() * 10) - 5);
						velY = (((Math.random() * -(velY)) / 4) + (-(velY) / 4));
						piece = new Hail(x, y, velX, velY, pieceSize, 5);
						GamePage.instance.addHail(piece);
						i++;
					};
				};
				remove();
			} else {
				y = (y - this.velY);
				x = (x - this.velX);
				this.velY = (-(this.velY) * 0.25);
				this.velX = ((Math.random() * (this.velY * 2)) - this.velY);
				size = (size * 0.9);
				setSize(size);
				if (size <= 0){
					remove();
				};
			};
		}
		private function go(e:Event):void{
			var vel:Number;
			var power:int;
			var hit:Boolean;
			rotation = (rotation + rotSpeed);
			velY = (velY + (gravity + (size * 0.003)));
			x = (x + velX);
			y = (y + velY);
			if (x < minX){
				x = maxX;
			};
			if (x > maxX){
				x = minX;
			};
			if (y > 0){
				if (invincible <= 0){
					vel = Maths.pythag(velX, velY);
					power = ((size * size) * vel);
					hit = GamePage.instance.hit(x, y, power);
					if (hit){
						hitSomething();
					};
				} else {
					invincible--;
				};
			};
			growCounter++;
			if (growCounter >= growCounterReset){
				growCounter = 0;
				if (y < 550){
					size = (size + 1);
					setSize(size);
				};
			};
			if (m.sizeMeasure.visible){
				m.sizeMeasure.rotation = -(rotation);
				m.sizeMeasure.sizeNum.text = (size + "m");
			};
		}

	}
}//package game 
Section 20
//IntroPage (menu.IntroPage)
package menu {
	import page.*;

	public class IntroPage extends Page {

		public function IntroPage():void{
			super();
			addChild(new IntroPageGraphic());
		}
	}
}//package menu 
Section 21
//MenuPage (menu.MenuPage)
package menu {
	import flash.events.*;
	import game.*;
	import page.*;
	import sounds.*;
	import flash.net.*;

	public class MenuPage extends Page {

		private var m:MenuPageGraphic;

		public function MenuPage():void{
			super();
			m = new MenuPageGraphic();
			m.playButton.addEventListener(MouseEvent.CLICK, clickPlay, false, 0, true);
			m.highscoreButton.addEventListener(MouseEvent.CLICK, clickHighscore, false, 0, true);
			m.programmingButton.addEventListener(MouseEvent.CLICK, clickProgramming, false, 0, true);
			m.artButton.addEventListener(MouseEvent.CLICK, clickArt, false, 0, true);
			m.armorGamesLogo.addEventListener(MouseEvent.CLICK, clickArmor, false, 0, true);
			addChild(m);
			Music.startGlideToVolume(0, 3);
		}
		private function clickProgramming(me:MouseEvent):void{
			navigateToURL(new URLRequest("http://jiggmin.com"), "_blank");
		}
		override public function remove():void{
			m.playButton.removeEventListener(MouseEvent.CLICK, clickPlay);
			m.highscoreButton.removeEventListener(MouseEvent.CLICK, clickHighscore);
			m.programmingButton.removeEventListener(MouseEvent.CLICK, clickProgramming);
			m.artButton.removeEventListener(MouseEvent.CLICK, clickArt);
			m.armorGamesLogo.removeEventListener(MouseEvent.CLICK, clickArmor);
			m = null;
			super.remove();
		}
		private function clickArmor(me:MouseEvent):void{
			navigateToURL(new URLRequest("http://armorgames.com/"), "_blank");
		}
		private function clickHighscore(me:MouseEvent):void{
			var agi:* = BaseClass.instance.agi;
			if (agi != null){
				agi.showScoreboardList();
			};
		}
		private function clickArt(me:MouseEvent):void{
			navigateToURL(new URLRequest("http://gregwohlwend.com"), "_blank");
		}
		private function clickPlay(me:MouseEvent):void{
			BaseClass.instance.setPage(new GamePage());
		}

	}
}//package menu 
Section 22
//SubmitPage (menu.SubmitPage)
package menu {
	import flash.events.*;
	import game.*;
	import page.*;
	import sounds.*;
	import data.*;

	public class SubmitPage extends Page {

		private var score:int;
		private var lesson:int;
		private var m:SubmitPageGraphic;

		public function SubmitPage(lesson:int, score:int, satellites:int, balloons:int, planes:int, buildings:int, homes:int, people:int):void{
			super();
			this.lesson = lesson;
			this.score = score;
			m = new SubmitPageGraphic();
			m.goBackButton.addEventListener(MouseEvent.CLICK, clickReturn, false, 0, true);
			if (BaseClass.instance.agi == null){
				m.submitButton.alpha = 0.5;
			} else {
				m.submitButton.addEventListener(MouseEvent.CLICK, clickSubmit, false, 0, true);
			};
			m.damageBox.text = (("$" + Data.commify(score)) + "(in millions)");
			m.satelliteBox.text = (satellites + " Satellites Lost");
			m.balloonBox.text = (balloons + " Weather Balloons Damaged");
			m.planeBox.text = (planes + " Planes Crashed");
			m.buildingBox.text = (buildings + " Skyscrapers Collapsed");
			m.homeBox.text = (homes + " Homes Destroyed");
			m.peopleBox.text = (people + " Pedestrians Injured");
			setBarHeight(1, ((((((satellites + balloons) + planes) + buildings) + homes) + people) / 6));
			setBarHeight(2, satellites);
			setBarHeight(3, balloons);
			setBarHeight(4, planes);
			setBarHeight(5, buildings);
			setBarHeight(6, homes);
			setBarHeight(7, people);
			if (lesson != 8){
				m.retryButton.addEventListener(MouseEvent.CLICK, clickRetry, false, 0, true);
			} else {
				m.retryButton.visible = false;
			};
			addChild(m);
			Music.startGlideToVolume(0.33, 3);
		}
		private function clickSubmit(me:MouseEvent):void{
			BaseClass.instance.agi.showScoreboardSubmit(score);
			m.submitButton.alpha = 0.5;
			m.submitButton.removeEventListener(MouseEvent.CLICK, clickSubmit);
		}
		private function clickReturn(me:MouseEvent):void{
			BaseClass.instance.setPage(new MenuPage());
		}
		private function clickRetry(me:MouseEvent):void{
			BaseClass.instance.setPage(new GamePage(lesson));
		}
		override public function remove():void{
			m.goBackButton.removeEventListener(MouseEvent.CLICK, clickReturn);
			m.retryButton.removeEventListener(MouseEvent.CLICK, clickRetry);
			m.submitButton.removeEventListener(MouseEvent.CLICK, clickSubmit);
			super.remove();
		}
		private function setBarHeight(bar:int, height:int):void{
			m.bars[("bar" + bar.toString())].height = ((height * 5) + 20);
		}

	}
}//package menu 
Section 23
//Page (page.Page)
package page {
	import flash.display.*;

	public class Page extends Sprite {

		public function Page():void{
			super();
		}
		public function initialize():void{
		}
		public function remove():void{
			if (parent != null){
				parent.removeChild(this);
			};
		}

	}
}//package page 
Section 24
//PageHolder (page.PageHolder)
package page {
	import basic.*;

	public class PageHolder extends Removable {

		private var curPage:Page;

		public function PageHolder():void{
			super();
		}
		public function setPage(newPage:Page):void{
			if (curPage != null){
				curPage.remove();
			};
			if (newPage != null){
				newPage.initialize();
				curPage = newPage;
				addChild(curPage);
			};
		}
		override public function remove():void{
			if (curPage != null){
				curPage.remove();
			};
			super.remove();
		}

	}
}//package page 
Section 25
//Preloader (preloader.Preloader)
package preloader {
	import flash.display.*;
	import flash.events.*;

	public class Preloader extends Sprite {

		private var rootRef:DisplayObject;
		private var m:PreloaderGraphic;

		public function Preloader(rootRef:DisplayObject):void{
			super();
			this.rootRef = rootRef;
			m = new PreloaderGraphic();
			addChild(m);
			addEventListener(Event.ENTER_FRAME, frameHandler, false, 0, true);
		}
		private function frameHandler(e:Event):void{
			if (rootRef.loaderInfo.bytesLoaded == rootRef.loaderInfo.bytesTotal){
				remove();
				MovieClip(parent).play();
			} else {
				m.bar.scaleX = (rootRef.loaderInfo.bytesLoaded / rootRef.loaderInfo.bytesTotal);
			};
		}
		public function remove():void{
			removeEventListener(Event.ENTER_FRAME, frameHandler);
			m = null;
			rootRef = null;
		}

	}
}//package preloader 
Section 26
//Music (sounds.Music)
package sounds {
	import flash.media.*;
	import flash.utils.*;

	public class Music {

		private static var volume:Number = 1;
		private static var glideInterval:uint;
		private static var soundChannel:SoundChannel;
		private static var intervalFreq:int = 250;

		public static function stopMusic():void{
			stopGlideToVolume();
			if (soundChannel != null){
				soundChannel.stop();
			};
		}
		private static function glideToVolume(volumeStep, targetVolume):void{
			volume = (volume + volumeStep);
			applyVolume(volume);
			if ((((volumeStep >= 0)) && ((volume >= targetVolume)))){
				volume = targetVolume;
				stopGlideToVolume();
			};
			if ((((volumeStep <= 0)) && ((volume <= targetVolume)))){
				volume = targetVolume;
				stopGlideToVolume();
			};
		}
		private static function applyVolume(volume:Number):void{
			var soundTransform:SoundTransform;
			if (soundChannel != null){
				soundTransform = new SoundTransform(volume);
				soundChannel.soundTransform = soundTransform;
			};
		}
		public static function startMusic(music:Sound):void{
			stopMusic();
			soundChannel = music.play(0, 999);
		}
		public static function startGlideToVolume(targetVolume:Number, seconds:Number):void{
			stopGlideToVolume();
			var volumeDist:Number = (targetVolume - volume);
			var ms:Number = (seconds * 1000);
			var steps:int = Math.ceil((ms / intervalFreq));
			var volumeStep:Number = (volumeDist / steps);
			glideInterval = setInterval(glideToVolume, intervalFreq, volumeStep, targetVolume);
		}
		public static function setVolume(volume:Number):void{
			stopGlideToVolume();
			Music.volume = volume;
			applyVolume(volume);
		}
		private static function stopGlideToVolume():void{
			clearInterval(glideInterval);
		}

	}
}//package sounds 
Section 27
//Mute (sounds.Mute)
package sounds {
	import flash.media.*;

	public class Mute {

		private static var muted:Boolean = false;

		public function Mute():void{
			super();
			trace("You're doin' it wrong! Mute is a static class.");
		}
		public static function doMute():void{
			if (muted){
				unmuteSound();
			} else {
				muteSound();
			};
		}
		public static function muteSound():void{
			muted = true;
			var st:SoundTransform = new SoundTransform(0, 0);
			SoundMixer.soundTransform = st;
		}
		public static function getMuted():Boolean{
			return (muted);
		}
		public static function unmuteSound():void{
			muted = false;
			var st:SoundTransform = new SoundTransform(1, 0);
			SoundMixer.soundTransform = st;
		}

	}
}//package sounds 
Section 28
//Sounds (sounds.Sounds)
package sounds {
	import flash.media.*;
	import flash.utils.*;

	public class Sounds {

		public static function startSound(sound:Sound, vol:Number=1, pan:Number=0, repeat:Number=0):SoundChannel{
			var settings:SoundTransform;
			var channel:SoundChannel;
			if (vol > 0.01){
				settings = new SoundTransform();
				settings.volume = vol;
				settings.pan = pan;
				channel = sound.play(0, repeat, settings);
				return (channel);
			};
			return (null);
		}
		public static function getSoundOption(soundStr:String, options:int):Sound{
			var num:int = Math.ceil((Math.random() * options));
			var soundClassName:String = (soundStr + num);
			var ClassReference:Class = (getDefinitionByName(soundClassName) as Class);
			var sound:Sound = new (ClassReference);
			return (sound);
		}

	}
}//package sounds 
Section 29
//StateObject (stateObjects.StateObject)
package stateObjects {
	import flash.display.*;
	import data.*;
	import basic.*;

	public class StateObject extends Removable {

		protected var state:String;
		protected var appendString:String;// = "Graphic"
		protected var m:MovieClip;
		protected var prependString:String;// = ""

		public function StateObject():void{
			super();
		}
		protected function setState(state:String):void{
			var capState:String;
			if (state != this.state){
				this.state = state;
				if (((!((m == null))) && (!((m.parent == null))))){
					m.parent.removeChild(m);
				};
				capState = (state.substr(0, 1).toUpperCase() + state.substr(1));
				m = Data.stringToObject(((prependString + capState) + appendString));
				addChild(m);
			};
		}
		public function getState():String{
			return (state);
		}

	}
}//package stateObjects 
Section 30
//MuteButton (ui.MuteButton)
package ui {
	import flash.events.*;
	import sounds.*;
	import stateObjects.*;

	public class MuteButton extends StateObject {

		public function MuteButton():void{
			super();
			prependString = "Mute";
			setState("off");
			buttonMode = true;
			useHandCursor = true;
			addEventListener(MouseEvent.CLICK, clickHandler, false, 0, true);
		}
		private function clickHandler(me:MouseEvent):void{
			Mute.doMute();
			var isMuted:Boolean = Mute.getMuted();
			if (isMuted){
				setState("on");
			} else {
				setState("off");
			};
		}
		override public function remove():void{
			removeEventListener(MouseEvent.CLICK, clickHandler);
			super.remove();
		}

	}
}//package ui 
Section 31
//ApplauseSound (ApplauseSound)
package {
	import flash.media.*;

	public dynamic class ApplauseSound extends Sound {

	}
}//package 
Section 32
//BaloonDieGraphic (BaloonDieGraphic)
package {
	import flash.display.*;

	public dynamic class BaloonDieGraphic extends MovieClip {

		public function BaloonDieGraphic(){
			addFrameScript(29, frame30);
		}
		function frame30(){
			stop();
		}

	}
}//package 
Section 33
//BaloonFloatGraphic (BaloonFloatGraphic)
package {
	import flash.display.*;

	public dynamic class BaloonFloatGraphic extends MovieClip {

	}
}//package 
Section 34
//BaseClass (BaseClass)
package {
	import flash.display.*;
	import flash.events.*;
	import page.*;
	import data.*;
	import menu.*;
	import ui.*;
	import flash.system.*;
	import flash.net.*;

	public class BaseClass extends PageHolder {

		public var agi;
		private var agiLoader:Loader;

		public static var instance:BaseClass;
		public static var width:int = 600;
		public static var height:int = 700;

		public function BaseClass():void{
			super();
		}
		public function init():void{
			BaseClass.instance = this;
			Stats.start();
			var mute:MuteButton = new MuteButton();
			mute.x = 10;
			mute.y = 673;
			mute.scaleX = (mute.scaleY = 0.8);
			stage.addChild(mute);
			if (Data.allowedURL(["armorgames.com"], true)){
				setPage(new IntroPage());
			};
			var agi_url:String = "http://agi.armorgames.com/assets/agi/AGI.swf";
			Security.allowDomain(agi_url);
			var urlRequest:URLRequest = new URLRequest(agi_url);
			agiLoader = new Loader();
			agiLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, loadComplete);
			agiLoader.load(urlRequest);
		}
		function handleAGIError(error:Object):void{
			trace(("AGI error: " + error));
		}
		function loadComplete(e:Event):void{
			agi = e.currentTarget.content;
			parent.addChild(agi);
			var devKey:String = "abe4756fe28c0da944002e72889bd257";
			var gameKey:String = "effing-hail";
			agi.init(devKey, gameKey);
		}

	}
}//package 
Section 35
//Beep1Sound (Beep1Sound)
package {
	import flash.media.*;

	public dynamic class Beep1Sound extends Sound {

	}
}//package 
Section 36
//Beep2Sound (Beep2Sound)
package {
	import flash.media.*;

	public dynamic class Beep2Sound extends Sound {

	}
}//package 
Section 37
//BuildingDieGraphic (BuildingDieGraphic)
package {
	import flash.display.*;

	public dynamic class BuildingDieGraphic extends MovieClip {

		public function BuildingDieGraphic(){
			addFrameScript(29, frame30);
		}
		function frame30(){
			stop();
		}

	}
}//package 
Section 38
//BuildingStandGraphic (BuildingStandGraphic)
package {
	import flash.display.*;

	public dynamic class BuildingStandGraphic extends MovieClip {

	}
}//package 
Section 39
//ExplosionGraphic (ExplosionGraphic)
package {
	import flash.display.*;

	public dynamic class ExplosionGraphic extends MovieClip {

		public var anim:MovieClip;
		public var text:MovieClip;

		public function ExplosionGraphic(){
			addFrameScript(31, frame32);
		}
		function frame32(){
			stop();
			if (parent != null){
				parent.removeChild(this);
			};
		}

	}
}//package 
Section 40
//ExplosionSound (ExplosionSound)
package {
	import flash.media.*;

	public dynamic class ExplosionSound extends Sound {

	}
}//package 
Section 41
//GamePageGraphic (GamePageGraphic)
package {
	import flash.display.*;
	import flash.text.*;

	public dynamic class GamePageGraphic extends MovieClip {

		public var instructions:MovieClip;
		public var hailHolder:MovieClip;
		public var lessonAnim:MovieClip;
		public var scoreBox:TextField;
		public var thingHolder:MovieClip;
		public var timeBox:TextField;

	}
}//package 
Section 42
//GameSong (GameSong)
package {
	import flash.media.*;

	public dynamic class GameSong extends Sound {

	}
}//package 
Section 43
//HailGraphic (HailGraphic)
package {
	import flash.display.*;

	public dynamic class HailGraphic extends MovieClip {

		public var sizeMeasure:MovieClip;

	}
}//package 
Section 44
//HighscorePageGraphic (HighscorePageGraphic)
package {
	import flash.display.*;
	import flash.text.*;

	public dynamic class HighscorePageGraphic extends MovieClip {

		public var goBackButton:SimpleButton;
		public var textBox:TextField;

	}
}//package 
Section 45
//HouseDieGraphic (HouseDieGraphic)
package {
	import flash.display.*;

	public dynamic class HouseDieGraphic extends MovieClip {

		public function HouseDieGraphic(){
			addFrameScript(29, frame30);
		}
		function frame30(){
			stop();
		}

	}
}//package 
Section 46
//HouseStandGraphic (HouseStandGraphic)
package {
	import flash.display.*;

	public dynamic class HouseStandGraphic extends MovieClip {

	}
}//package 
Section 47
//IntroPageGraphic (IntroPageGraphic)
package {
	import flash.display.*;
	import menu.*;

	public dynamic class IntroPageGraphic extends MovieClip {

		public function IntroPageGraphic(){
			addFrameScript(0, frame1, 91, frame92);
		}
		function frame1(){
			stop();
		}
		function frame92(){
			BaseClass.instance.setPage(new MenuPage());
			stop();
		}

	}
}//package 
Section 48
//MenuPageGraphic (MenuPageGraphic)
package {
	import flash.display.*;
	import flash.text.*;

	public dynamic class MenuPageGraphic extends MovieClip {

		public var highscoreButton:SimpleButton;
		public var playButton:SimpleButton;
		public var programmingButton:SimpleButton;
		public var armorGamesLogo:SimpleButton;
		public var artButton:SimpleButton;
		public var textBox:TextField;

	}
}//package 
Section 49
//MuteOffGraphic (MuteOffGraphic)
package {
	import flash.display.*;

	public dynamic class MuteOffGraphic extends MovieClip {

	}
}//package 
Section 50
//MuteOnGraphic (MuteOnGraphic)
package {
	import flash.display.*;

	public dynamic class MuteOnGraphic extends MovieClip {

	}
}//package 
Section 51
//PersonDieGraphic (PersonDieGraphic)
package {
	import flash.display.*;

	public dynamic class PersonDieGraphic extends MovieClip {

		public function PersonDieGraphic(){
			addFrameScript(29, frame30);
		}
		function frame30(){
			stop();
		}

	}
}//package 
Section 52
//PersonWalkGraphic (PersonWalkGraphic)
package {
	import flash.display.*;

	public dynamic class PersonWalkGraphic extends MovieClip {

	}
}//package 
Section 53
//PlaneDieGraphic (PlaneDieGraphic)
package {
	import flash.display.*;

	public dynamic class PlaneDieGraphic extends MovieClip {

		public function PlaneDieGraphic(){
			addFrameScript(89, frame90);
		}
		function frame90(){
			stop();
		}

	}
}//package 
Section 54
//PlaneFlyGraphic (PlaneFlyGraphic)
package {
	import flash.display.*;

	public dynamic class PlaneFlyGraphic extends MovieClip {

	}
}//package 
Section 55
//PreloaderGraphic (PreloaderGraphic)
package {
	import flash.display.*;

	public dynamic class PreloaderGraphic extends MovieClip {

		public var bar:MovieClip;

	}
}//package 
Section 56
//SatelliteDieGraphic (SatelliteDieGraphic)
package {
	import flash.display.*;

	public dynamic class SatelliteDieGraphic extends MovieClip {

		public function SatelliteDieGraphic(){
			addFrameScript(59, frame60);
		}
		function frame60(){
			stop();
		}

	}
}//package 
Section 57
//SatelliteFloatGraphic (SatelliteFloatGraphic)
package {
	import flash.display.*;

	public dynamic class SatelliteFloatGraphic extends MovieClip {

	}
}//package 
Section 58
//SubmitPageGraphic (SubmitPageGraphic)
package {
	import flash.display.*;
	import flash.text.*;

	public dynamic class SubmitPageGraphic extends MovieClip {

		public var bars:MovieClip;
		public var goBackButton:SimpleButton;
		public var peopleBox:TextField;
		public var planeBox:TextField;
		public var satelliteBox:TextField;
		public var balloonBox:TextField;
		public var damageBox:TextField;
		public var textBox:TextField;
		public var submitButton:SimpleButton;
		public var homeBox:TextField;
		public var buildingBox:TextField;
		public var retryButton:SimpleButton;

	}
}//package 
Section 59
//WindGraphic (WindGraphic)
package {
	import flash.display.*;

	public dynamic class WindGraphic extends MovieClip {

		public function WindGraphic(){
			addFrameScript(0, frame1);
		}
		function frame1(){
			stop();
		}

	}
}//package 
Section 60
//WindSound (WindSound)
package {
	import flash.media.*;

	public dynamic class WindSound extends Sound {

	}
}//package