Initial commit

src/package_15/name_19.as

@@ -0,0 +1,59 @@
+package package_15
+{
+   public class name_19
+   {
+      private var data:Object;
+      
+      public function name_19(data:Object = null)
+      {
+         super();
+         this.data = data || new Object();
+      }
+      
+      public function method_24(key:String) : String
+      {
+         return this.data[key];
+      }
+      
+      public function method_25(key:String, defaultValue:String) : String
+      {
+         return this.data[key] || defaultValue;
+      }
+      
+      public function method_27(key:String, value:String) : void
+      {
+         if(!value)
+         {
+            throw new ArgumentError("Empty values are not allowed");
+         }
+         this.data[key] = value;
+      }
+      
+      public function get method_26() : Vector.<String>
+      {
+         var name:String = null;
+         var names:Vector.<String> = new Vector.<String>();
+         for(name in this.data)
+         {
+            names.push(name);
+         }
+         return names;
+      }
+      
+      public function toString() : String
+      {
+         var key:String = null;
+         var result:String = "";
+         for(key in this.data)
+         {
+            if(Boolean(result))
+            {
+               result += ", ";
+            }
+            result += key + ": " + this.data[key];
+         }
+         return "[Properties " + result + "]";
+      }
+   }
+}
+

src/package_15/name_191.as

@@ -0,0 +1,207 @@
+package package_15
+{
+   public class name_191
+   {
+      public static const A:uint = 65;
+      
+      public static const B:uint = 66;
+      
+      public static const C:uint = 67;
+      
+      public static const D:uint = 68;
+      
+      public static const E:uint = 69;
+      
+      public static const F:uint = 70;
+      
+      public static const G:uint = 71;
+      
+      public static const H:uint = 72;
+      
+      public static const I:uint = 73;
+      
+      public static const J:uint = 74;
+      
+      public static const K:uint = 75;
+      
+      public static const L:uint = 76;
+      
+      public static const M:uint = 77;
+      
+      public static const N:uint = 78;
+      
+      public static const O:uint = 79;
+      
+      public static const P:uint = 80;
+      
+      public static const Q:uint = 81;
+      
+      public static const R:uint = 82;
+      
+      public static const S:uint = 83;
+      
+      public static const T:uint = 84;
+      
+      public static const U:uint = 85;
+      
+      public static const V:uint = 86;
+      
+      public static const W:uint = 87;
+      
+      public static const X:uint = 88;
+      
+      public static const Y:uint = 89;
+      
+      public static const Z:uint = 90;
+      
+      public static const SPACE:uint = 32;
+      
+      public static const SEMICOLON:uint = 186;
+      
+      public static const COMMA:uint = 188;
+      
+      public static const PERIOD:uint = 190;
+      
+      public static const SLASH:uint = 191;
+      
+      public static const BACKQUOTE:uint = 192;
+      
+      public static const LEFTBRACKET:uint = 219;
+      
+      public static const BACKSLASH:uint = 220;
+      
+      public static const RIGHTBRACKET:uint = 221;
+      
+      public static const QUOTE:uint = 222;
+      
+      public static const BACKSPACE:uint = 8;
+      
+      public static const TAB:uint = 9;
+      
+      public static const PAGE_UP:uint = 33;
+      
+      public static const PAGE_DOWN:uint = 34;
+      
+      public static const END:uint = 35;
+      
+      public static const HOME:uint = 36;
+      
+      public static const INSERT:uint = 45;
+      
+      public static const DELETE:uint = 46;
+      
+      public static const NUMBER_0:uint = 48;
+      
+      public static const NUMBER_1:uint = 49;
+      
+      public static const NUMBER_2:uint = 50;
+      
+      public static const NUMBER_3:uint = 51;
+      
+      public static const NUMBER_4:uint = 52;
+      
+      public static const NUMBER_5:uint = 53;
+      
+      public static const NUMBER_6:uint = 54;
+      
+      public static const NUMBER_7:uint = 55;
+      
+      public static const NUMBER_8:uint = 56;
+      
+      public static const NUMBER_9:uint = 57;
+      
+      public static const EQUAL:uint = 187;
+      
+      public static const MINUS:uint = 189;
+      
+      public static const NUMPAD:uint = 21;
+      
+      public static const NUMPAD_0:uint = 96;
+      
+      public static const NUMPAD_1:uint = 97;
+      
+      public static const NUMPAD_2:uint = 98;
+      
+      public static const NUMPAD_3:uint = 99;
+      
+      public static const NUMPAD_4:uint = 100;
+      
+      public static const NUMPAD_5:uint = 101;
+      
+      public static const NUMPAD_6:uint = 102;
+      
+      public static const NUMPAD_7:uint = 103;
+      
+      public static const NUMPAD_8:uint = 104;
+      
+      public static const NUMPAD_9:uint = 105;
+      
+      public static const NUMPAD_ADD:uint = 107;
+      
+      public static const NUMPAD_DECIMAL:uint = 110;
+      
+      public static const NUMPAD_DIVIDE:uint = 111;
+      
+      public static const NUMPAD_ENTER:uint = 108;
+      
+      public static const NUMPAD_MULTIPLY:uint = 106;
+      
+      public static const NUMPAD_SUBTRACT:uint = 109;
+      
+      public static const ENTER:uint = 13;
+      
+      public static const COMMAND:uint = 15;
+      
+      public static const SHIFT:uint = 16;
+      
+      public static const CONTROL:uint = 17;
+      
+      public static const CAPS_LOCK:uint = 20;
+      
+      public static const ESCAPE:uint = 27;
+      
+      public static const LEFT:uint = 37;
+      
+      public static const UP:uint = 38;
+      
+      public static const RIGHT:uint = 39;
+      
+      public static const DOWN:uint = 40;
+      
+      public static const F1:uint = 112;
+      
+      public static const F2:uint = 113;
+      
+      public static const F3:uint = 114;
+      
+      public static const F4:uint = 115;
+      
+      public static const F5:uint = 116;
+      
+      public static const F6:uint = 117;
+      
+      public static const F7:uint = 118;
+      
+      public static const F8:uint = 119;
+      
+      public static const F9:uint = 120;
+      
+      public static const F10:uint = 121;
+      
+      public static const F11:uint = 122;
+      
+      public static const F12:uint = 123;
+      
+      public static const F13:uint = 124;
+      
+      public static const F14:uint = 125;
+      
+      public static const F15:uint = 126;
+      
+      public function name_191()
+      {
+         super();
+      }
+   }
+}
+

src/package_15/name_275.as

@@ -0,0 +1,121 @@
+package package_15
+{
+   import flash.geom.ColorTransform;
+   
+   public class name_275
+   {
+      public static const BLACK:uint = 0;
+      
+      public static const RED:uint = 8323072;
+      
+      public static const GREEN:uint = 32512;
+      
+      public static const BLUE:uint = 127;
+      
+      public static const BROWN:uint = 8355584;
+      
+      public static const CYAN:uint = 32639;
+      
+      public static const MAGENTA:uint = 8323199;
+      
+      public static const GRAY:uint = 8355711;
+      
+      public static const LIGHT_RED:uint = 16711680;
+      
+      public static const LIGHT_GREEN:uint = 65280;
+      
+      public static const LIGHT_BLUE:uint = 255;
+      
+      public static const YELLOW:uint = 16776960;
+      
+      public static const LIGHT_CYAN:uint = 65535;
+      
+      public static const LIGHT_MAGENTA:uint = 16711935;
+      
+      public static const WHITE:uint = 16777215;
+      
+      public function name_275()
+      {
+         super();
+      }
+      
+      public static function sum(a:uint, b:uint) : uint
+      {
+         var red:int = (a & 0xFF0000) + (b & 0xFF0000);
+         var green:int = (a & 0xFF00) + (b & 0xFF00);
+         var blue:int = (a & 0xFF) + (b & 0xFF);
+         return (Boolean(red >>> 24) ? 16711680 : red) + (Boolean(green >>> 16) ? 65280 : green) + (Boolean(blue >>> 8) ? 255 : blue);
+      }
+      
+      public static function difference(a:uint, b:uint) : uint
+      {
+         var red:int = (a & 0xFF0000) - (b & 0xFF0000);
+         var green:int = (a & 0xFF00) - (b & 0xFF00);
+         var blue:int = (a & 0xFF) - (b & 0xFF);
+         return (red < 0 ? 0 : red) + (green < 0 ? 0 : green) + (blue < 0 ? 0 : blue);
+      }
+      
+      public static function method_552(color:uint, multiplier:Number) : uint
+      {
+         var red:int = ((color & 0xFF0000) >>> 16) * multiplier;
+         var green:int = ((color & 0xFF00) >>> 8) * multiplier;
+         var blue:int = (color & 0xFF) * multiplier;
+         return name_345(red,green,blue);
+      }
+      
+      public static function interpolate(a:uint, b:uint, k:Number = 0.5) : uint
+      {
+         var red:int = (a & 0xFF0000) >>> 16;
+         red += (((b & 0xFF0000) >>> 16) - red) * k;
+         var green:int = (a & 0xFF00) >>> 8;
+         green += (((b & 0xFF00) >>> 8) - green) * k;
+         var blue:int = a & 0xFF;
+         blue += ((b & 0xFF) - blue) * k;
+         return name_345(red,green,blue);
+      }
+      
+      public static function method_551(fromColor:ColorTransform, toColor:ColorTransform, progress:Number, result:ColorTransform = null) : ColorTransform
+      {
+         if(result == null)
+         {
+            result = new ColorTransform();
+         }
+         var k:Number = 1 - progress;
+         result.redMultiplier = fromColor.redMultiplier * k + toColor.redMultiplier * progress;
+         result.greenMultiplier = fromColor.greenMultiplier * k + toColor.greenMultiplier * progress;
+         result.blueMultiplier = fromColor.blueMultiplier * k + toColor.blueMultiplier * progress;
+         result.alphaMultiplier = fromColor.alphaMultiplier * k + toColor.alphaMultiplier * progress;
+         result.redOffset = fromColor.redOffset * k + toColor.redOffset * progress;
+         result.greenOffset = fromColor.greenOffset * k + toColor.greenOffset * progress;
+         result.blueOffset = fromColor.blueOffset * k + toColor.blueOffset * progress;
+         result.alphaOffset = fromColor.alphaOffset * k + toColor.alphaOffset * progress;
+         return result;
+      }
+      
+      public static function random(redMin:uint = 0, redMax:uint = 255, greenMin:uint = 0, greenMax:uint = 255, blueMin:uint = 0, blueMax:uint = 255) : uint
+      {
+         return name_345(name_629.random(redMin,redMax),name_629.random(greenMin,greenMax),name_629.random(blueMin,blueMax));
+      }
+      
+      public static function name_345(red:int, green:int, blue:int) : uint
+      {
+         return (red < 0 ? 0 : (Boolean(red >>> 8) ? 16711680 : red << 16)) + (green < 0 ? 0 : (Boolean(green >>> 8) ? 65280 : green << 8)) + (blue < 0 ? 0 : (Boolean(blue >>> 8) ? 255 : blue));
+      }
+      
+      public static function red(color:uint) : uint
+      {
+         return (color & 0xFF0000) >>> 16;
+      }
+      
+      public static function green(color:uint) : uint
+      {
+         return (color & 0xFF00) >>> 8;
+      }
+      
+      public static function blue(color:uint) : uint
+      {
+         return color & 0xFF;
+      }
+   }
+}
+

src/package_15/name_55.as

@@ -0,0 +1,31 @@
+package package_15
+{
+   import flash.utils.ByteArray;
+   
+   public class name_55
+   {
+      private var var_102:Object;
+      
+      public function name_55(data:Object = null)
+      {
+         super();
+         this.var_102 = data == null ? {} : data;
+      }
+      
+      public function get data() : Object
+      {
+         return this.var_102;
+      }
+      
+      public function name_248(key:String) : ByteArray
+      {
+         return this.var_102[key];
+      }
+      
+      public function name_59(key:String, value:ByteArray) : void
+      {
+         this.var_102[key] = value;
+      }
+   }
+}
+

src/package_15/name_629.as

@@ -0,0 +1,141 @@
+package package_15
+{
+   import flash.geom.Point;
+   
+   public final class name_629
+   {
+      private static const toRad:Number = Math.PI / 180;
+      
+      private static const toDeg:Number = 180 / Math.PI;
+      
+      public static const DEG1:Number = toRad;
+      
+      public static const DEG5:Number = Math.PI / 36;
+      
+      public static const DEG10:Number = Math.PI / 18;
+      
+      public static const DEG30:Number = Math.PI / 6;
+      
+      public static const DEG45:Number = Math.PI / 4;
+      
+      public static const DEG60:Number = Math.PI / 3;
+      
+      public static const DEG90:Number = Math.PI / 2;
+      
+      public static const DEG180:Number = Math.PI;
+      
+      public static const DEG360:Number = Math.PI + Math.PI;
+      
+      public function name_629()
+      {
+         super();
+      }
+      
+      public static function method_806(angle:Number) : Number
+      {
+         return angle * toRad;
+      }
+      
+      public static function method_801(angle:Number) : Number
+      {
+         return angle * toDeg;
+      }
+      
+      public static function method_802(angle:Number) : Number
+      {
+         var res:Number = angle % DEG360;
+         return res > 0 ? (res > DEG180 ? res - DEG360 : res) : (res < -DEG180 ? res + DEG360 : res);
+      }
+      
+      public static function method_805(a:Number, b:Number) : Number
+      {
+         var delta:Number = b - a;
+         if(delta > DEG180)
+         {
+            return delta - DEG360;
+         }
+         if(delta < -DEG180)
+         {
+            return delta + DEG360;
+         }
+         return delta;
+      }
+      
+      public static function random(a:Number = NaN, b:Number = NaN) : Number
+      {
+         if(isNaN(a))
+         {
+            return Math.random();
+         }
+         if(isNaN(b))
+         {
+            return Math.random() * a;
+         }
+         return Math.random() * (b - a) + a;
+      }
+      
+      public static function method_807() : Number
+      {
+         return Math.random() * DEG360;
+      }
+      
+      public static function method_803(a:Number, b:Number, threshold:Number = 0) : Boolean
+      {
+         return b - a <= threshold && b - a >= -threshold;
+      }
+      
+      public static function method_809(first:Point, second:Point, point:Point) : Number
+      {
+         var dx:Number = second.x - first.x;
+         var dy:Number = second.y - first.y;
+         var px:Number = point.x - first.x;
+         var py:Number = point.y - first.y;
+         return (dx * py - dy * px) / Math.sqrt(dx * dx + dy * dy);
+      }
+      
+      public static function method_804(a:Point, b:Point, c:Point, point:Point) : Boolean
+      {
+         if(method_799(c.subtract(a),point.subtract(a)) <= 0)
+         {
+            if(method_799(b.subtract(c),point.subtract(c)) <= 0)
+            {
+               if(method_799(a.subtract(b),point.subtract(b)) <= 0)
+               {
+                  return true;
+               }
+               return false;
+            }
+            return false;
+         }
+         return false;
+      }
+      
+      public static function method_799(a:Point, b:Point) : Number
+      {
+         return a.x * b.y - a.y * b.x;
+      }
+      
+      public static function method_800(a:Point, b:Point) : Number
+      {
+         return a.x * b.x + a.y * b.y;
+      }
+      
+      public static function method_810(a:Point, b:Point) : Number
+      {
+         var len:Number = a.length * b.length;
+         var cos:Number = len != 0 ? method_800(a,b) / len : 1;
+         return Math.acos(cos);
+      }
+      
+      public static function method_808(a:Point, b:Point) : Number
+      {
+         var dot:Number = method_800(a,b);
+         if(Math.abs(dot) > 1)
+         {
+            dot = dot > 0 ? 1 : -1;
+         }
+         return Math.acos(dot);
+      }
+   }
+}
+

src/package_15/name_632.as

@@ -0,0 +1,10 @@
+package package_15
+{
+   public interface name_632
+   {
+      function hasNext() : Boolean;
+      
+      function getNext() : String;
+   }
+}
+

src/package_15/name_634.as

@@ -0,0 +1,128 @@
+package package_15
+{
+   public class name_634 implements name_635
+   {
+      public var strings:Vector.<String>;
+      
+      public var var_665:int;
+      
+      public var var_664:int;
+      
+      private var var_666:int;
+      
+      public function name_634(capacity:int)
+      {
+         super();
+         this.var_666 = capacity;
+         this.strings = new Vector.<String>(this.var_666 + 1);
+      }
+      
+      public function add(s:String) : void
+      {
+         this.strings[this.var_664] = s;
+         this.var_664 = this.incIndex(this.var_664);
+         if(this.var_664 == this.var_665)
+         {
+            this.var_665 = this.incIndex(this.var_665);
+         }
+      }
+      
+      public function clear() : void
+      {
+         this.var_665 = 0;
+         this.var_664 = 0;
+         var len:int = int(this.strings.length);
+         for(var i:int = 0; i < len; i++)
+         {
+            this.strings[i] = null;
+         }
+      }
+      
+      public function get size() : int
+      {
+         var result:int = this.var_664 - this.var_665;
+         if(result < 0)
+         {
+            result += this.strings.length;
+         }
+         return result;
+      }
+      
+      public function get capacity() : int
+      {
+         return this.var_666;
+      }
+      
+      public function name_638() : Vector.<String>
+      {
+         var result:Vector.<String> = new Vector.<String>();
+         for(var i:int = this.var_665; i != this.var_664; i = this.incIndex(i))
+         {
+            result.push(this.strings[i]);
+         }
+         return result;
+      }
+      
+      public function set capacity(value:int) : void
+      {
+         throw new Error("Unimplemented");
+      }
+      
+      public function name_633(startIndex:int) : name_632
+      {
+         return new Iterator(this,startIndex);
+      }
+      
+      private function incIndex(index:int) : int
+      {
+         return ++index >= this.strings.length ? 0 : index;
+      }
+   }
+}
+
+class Iterator implements name_632
+{
+   private var buffer:name_634;
+   
+   private var index:int;
+   
+   public function Iterator(buffer:name_634, startIndex:int)
+   {
+      super();
+      if(startIndex < 0 || startIndex > buffer.size)
+      {
+         throw new Error("Index " + startIndex + " is out of range [0, " + buffer.size + "]");
+      }
+      this.buffer = buffer;
+      var bufferLength:uint = uint(buffer.strings.length);
+      this.index = buffer.var_665 + startIndex - 1;
+      if(this.index < 0)
+      {
+         this.index = bufferLength - 1;
+      }
+      if(this.index >= bufferLength)
+      {
+         this.index -= bufferLength;
+      }
+   }
+   
+   public function hasNext() : Boolean
+   {
+      return this.incIndex(this.index) != this.buffer.var_664;
+   }
+   
+   public function getNext() : String
+   {
+      this.index = this.incIndex(this.index);
+      if(this.index == this.buffer.var_664)
+      {
+         throw new Error("End of buffer");
+      }
+      return this.buffer.strings[this.index];
+   }
+   
+   private function incIndex(index:int) : int
+   {
+      return ++index >= this.buffer.strings.length ? 0 : index;
+   }
+}

src/package_15/name_635.as

@@ -0,0 +1,18 @@
+package package_15
+{
+   public interface name_635
+   {
+      function add(param1:String) : void;
+      
+      function clear() : void;
+      
+      function get size() : int;
+      
+      function get capacity() : int;
+      
+      function set capacity(param1:int) : void;
+      
+      function name_633(param1:int) : name_632;
+   }
+}
+

src/package_15/name_718.as

@@ -0,0 +1,21 @@
+package package_15
+{
+   public class name_718
+   {
+      public function name_718()
+      {
+         super();
+      }
+      
+      public static function name_719(msg:String, ... args) : String
+      {
+         var len:int = int(args.length);
+         for(var i:int = 0; i < len; i++)
+         {
+            msg = msg.replace(new RegExp("%" + (i + 1),"g"),args[i]);
+         }
+         return msg;
+      }
+   }
+}
+