var i:int;
            const REPS:int = 5000000;
            var beforeTime:int;
            var afterTime:int;//*
            var val1Int:int = 1;
            var val2Int:int = 2;
            var val3Int:int = 3;
            var val4Int:int = 0;
            var val5Int:int = 0;
            var val1Uint:uint = 1;
            var val2Uint:uint = 2;
            var val3Uint:uint = 3;
            var val4Uint:uint = 0;
            var val5Uint:uint = 0;
            var val1Number:Number = 0.3333;
            var val2Number:Number = 0.6666;
            var val3Number:Number = 0.9999;
            var val4Number:Number = 0;
            var val5Number:Number = 0;
            var val6Number:Number = 0;
            var val1String:String = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
            var val2String:String = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
            var r:*;
            beforeTime = getTimer();
            for (i = REPS; i--; ) void;
            afterTime = getTimer();
            log(REPS + " Loops; 10 Tests per loop\nEmpty Loop: " + (afterTime-beforeTime) + "\n\n");

              log("       ║    int     ║    uint    ║  int/uint  ║   Number   ║ Number/int ║  Number/uint\n");
              log("═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");

              log("&:     ║");
              //{  &

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitAndInt10(val1Int, val3Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitAndUint10(val1Uint, val3Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitAndIntUint10(val1Int, val3Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitAndNumber10(val1Number, val5Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitAndNumberInt10(val5Number, val3Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitAndNumberUint10(val5Number, val3Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("|:     ║");
              //{  |

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitOrInt10(val1Int, val4Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitOrUint10(val1Uint, val4Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitOrIntUint10(val1Int, val4Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitOrNumber10(val5Number, val4Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitOrNumberInt10(val5Number, val4Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitOrNumberUint10(val5Number, val4Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("^:     ║");
              //{  ^

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitXorInt10(val1Int, val4Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitXorUint10(val1Uint, val4Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitXorIntUint10(val1Int, val4Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitXorNumber10(val4Number, val5Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitXorNumberInt10(val5Number, val4Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitXorNumberUint10(val5Number, val4Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("~:     ║");
              //{  ~

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitNotInt10(val5Int, val5Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitNotUint10(val5Uint, val5Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.BitNotNumber10(val6Number, val6Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ");
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log(">>:    ║");
              //{  >>

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightInt10(val1Int, val4Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUint10(val1Uint, val4Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightIntUint10(val1Int, val4Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightNumber10(val5Number, val4Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightNumberInt10(val5Number, val4Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightNumberUint10(val5Number, val4Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log(">>>:   ║");
              //{  >>>

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUnsignedInt10(val1Int, val4Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUnsignedUint10(val1Uint, val4Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUnsignedIntUint10(val1Int, val4Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUnsignedNumber10(val5Number, val4Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUnsignedNumberInt10(val5Number, val4Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftRightUnsignedNumberUint10(val5Number, val4Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("<<:    ║");
              //{  <<

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftLeftInt10(val1Int, val4Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftLeftUint10(val1Uint, val4Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftLeftIntUint10(val1Int, val4Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftLeftNumber10(val5Number, val4Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftLeftNumberInt10(val5Number, val4Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ShiftLeftNumberUint10(val5Number, val4Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("+:     ║");
              //{  +

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.AddInt10(val4Int, val2Int, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.AddUint10(val4Uint, val2Uint, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.AddIntUint10(val4Int, val2Uint, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.AddNumber10(val1Number, val5Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.AddNumberInt10(val5Number, val2Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.AddNumberUint10(val5Number, val2Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("-:     ║");
              //{  -

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.SubtractInt10(val1Int, val4Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.SubtractUint10(val1Uint, val4Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.SubtractIntUint10(val1Int, val4Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.SubtractNumber10(val1Number, val5Number, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.SubtractNumberInt10(val1Number, val4Int, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.SubtractNumberUint10(val1Number, val4Uint, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("*:     ║");
              //{  *

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.MultiplyInt10(val4Int, val2Int, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.MultiplyUint10(val4Uint, val2Uint, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.MultiplyIntUint10(val4Int, val2Uint, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.MultiplyNumber10(val4Number, val2Number, val4Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.MultiplyNumberInt10(val5Number, val2Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.MultiplyNumberUint10(val5Number, val2Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("/:     ║");
              //{  /

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DivideInt10(val4Int, val1Int, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DivideUint10(val4Uint, val1Uint, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DivideIntUint10(val4Int, val1Uint, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DivideNumber10(val5Number, val1Number, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DivideNumberInt10(val5Number, val1Int, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DivideNumberUint10(val5Number, val1Uint, val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("%:     ║");
              //{  %

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ModuloInt10(val1Int, val2Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ModuloUint10(val1Uint, val2Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ModuloIntUint10(val1Int, val2Uint, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ModuloNumber10(val1Number, val2Number, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ModuloNumberInt10(val1Number, val2Int, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.ModuloNumberUint10(val1Number, val2Uint, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("++v:   ║");
              //{  ++

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.IncrementInt10(val4Int, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.IncrementUint10(val4Uint, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.IncrementNumber10(val4Number, val4Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ");
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("inc v: ║");
              //{ IncLocal

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.IncLocalInt10(val3Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.IncLocalNumber10(val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ");
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("--v:   ║");
              //{  --

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DecrementInt10(val4Int, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DecrementUint10(val4Uint, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DecrementNumber10(val4Number, val4Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ");
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("dec v: ║");
              //{  DecLocal

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DecLocalInt10(val3Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.DecLocalNumber10(val5Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ");
              //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("==:    ║");
              //{  ==

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualsInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualsUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualsIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualsNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualsNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualsNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("===:   ║");
              //{  ===

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictEqualsInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictEqualsUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictEqualsIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictEqualsNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictEqualsNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictEqualsNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("!=:    ║");
              //{  !=

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotEqualsInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotEqualsUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotEqualsIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotEqualsNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotEqualsNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotEqualsNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("!==:   ║");
              //{  !==

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictNotEqualsInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictNotEqualsUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictNotEqualsIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictNotEqualsNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictNotEqualsNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.StrictNotEqualsNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log(">:     ║");
              //{  >

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterThanInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterThanUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterThanIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterThanNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterThanNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterThanNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("<:     ║");
              //{  <

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessThanInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessThanUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessThanIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessThanNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessThanNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessThanNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log(">=:    ║");
              //{  >=

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterEqualsInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterEqualsUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterEqualsIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterEqualsNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterEqualsNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.GreaterEqualsNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("<=:    ║");
              //{  <=

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessEqualsInt10(val1Int, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessEqualsUint10(val1Uint, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessEqualsIntUint10(val1Int, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessEqualsNumber10(val1Number, val2Number, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessEqualsNumberInt10(val1Number, val2Int, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.LessEqualsNumberUint10(val1Number, val2Uint, r);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("!:     ║");
              //{  !

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotInt10(r, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotUint10(r, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.NotNumber10(r, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║    n/a     ║    n/a     ");
            //}

            log("\n═══════╬════════════╬════════════╬════════════╬════════════╬════════════╬════════════════\n");
              log("=:     ║");
              //{  =

            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualInt10(val1Int, val1Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualUint10(val1Uint, val1Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualIntUint10(val4Int, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualNumber10(val1Number, val1Number);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualNumberInt10(val4Number, val4Int);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            log("║");
            beforeTime = getTimer();
            for (i = REPS; i--; ) {
                Operators.EqualNumberUint10(val4Number, val4Uint);
            }
            afterTime = getTimer();
            log(format(afterTime-beforeTime));
            //}


    import apparat.inline.*;
    import apparat.asm.*;
    import apparat.memory.Memory;
    /**
     * ...
     * @author skyboy
     */
    public class Operators extends Macro {
        //{ +
        public static function AddInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), AddInt, SetLocal(r));
        }
        public static function AddInt10(a:int, b:int, r:*):void {
            Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r);
            Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r); Operators.AddInt1(a, b, r);
        }
        public static function AddUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), AddInt, ConvertUInt, SetLocal(r));
        }
        public static function AddUint10(a:uint, b:uint, r:*):void {
            Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r);
            Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r); Operators.AddUint1(a, b, r);
        }
        public static function AddIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), AddInt, SetLocal(r));
        }
        public static function AddIntUint10(a:int, b:uint, r:*):void {
            Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r);
            Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r); Operators.AddIntUint1(a, b, r);
        }
        public static function AddNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Add, SetLocal(r));
        }
        public static function AddNumber10(a:Number, b:Number, r:*):void {
            Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r);
            Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r); Operators.AddNumber1(a, b, r);
        }
        public static function AddNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Add, SetLocal(r));
        }
        public static function AddNumberInt10(a:Number, b:int, r:*):void {
            Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r);
            Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r); Operators.AddNumberInt1(a, b, r);
        }
        public static function AddNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Add, SetLocal(r));
        }
        public static function AddNumberUint10(a:Number, b:uint, r:*):void {
            Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r);
            Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r); Operators.AddNumberUint1(a, b, r);
        }
        //}
        //{ -
        public static function SubtractInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), SubtractInt, SetLocal(r));
        }
        public static function SubtractInt10(a:int, b:int, r:*):void {
            Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r);
            Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r); Operators.SubtractInt1(a, b, r);
        }
        public static function SubtractUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), SubtractInt, ConvertUInt, SetLocal(r));
        }
        public static function SubtractUint10(a:uint, b:uint, r:*):void {
            Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r);
            Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r); Operators.SubtractUint1(a, b, r);
        }
        public static function SubtractIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), SubtractInt, SetLocal(r));
        }
        public static function SubtractIntUint10(a:int, b:uint, r:*):void {
            Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r);
            Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r); Operators.SubtractIntUint1(a, b, r);
        }
        public static function SubtractNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Subtract, SetLocal(r));
        }
        public static function SubtractNumber10(a:Number, b:Number, r:*):void {
            Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r);
            Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r); Operators.SubtractNumber1(a, b, r);
        }
        public static function SubtractNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Subtract, SetLocal(r));
        }
        public static function SubtractNumberInt10(a:Number, b:int, r:*):void {
            Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r);
            Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r); Operators.SubtractNumberInt1(a, b, r);
        }
        public static function SubtractNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Subtract, SetLocal(r));
        }
        public static function SubtractNumberUint10(a:Number, b:uint, r:*):void {
            Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r);
            Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r); Operators.SubtractNumberUint1(a, b, r);
        }
        //}
        //{ *
        public static function MultiplyInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), MultiplyInt, SetLocal(r));
        }
        public static function MultiplyInt10(a:int, b:int, r:*):void {
            Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r);
            Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r); Operators.MultiplyInt1(a, b, r);
        }
        public static function MultiplyUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), MultiplyInt, ConvertUInt, SetLocal(r));
        }
        public static function MultiplyUint10(a:uint, b:uint, r:*):void {
            Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r);
            Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r); Operators.MultiplyUint1(a, b, r);
        }
        public static function MultiplyIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), MultiplyInt, SetLocal(r));
        }
        public static function MultiplyIntUint10(a:int, b:uint, r:*):void {
            Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r);
            Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r); Operators.MultiplyIntUint1(a, b, r);
        }
        public static function MultiplyNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Multiply, SetLocal(r));
        }
        public static function MultiplyNumber10(a:Number, b:Number, r:*):void {
            Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r);
            Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r); Operators.MultiplyNumber1(a, b, r);
        }
        public static function MultiplyNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Multiply, SetLocal(r));
        }
        public static function MultiplyNumberInt10(a:Number, b:int, r:*):void {
            Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r);
            Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r); Operators.MultiplyNumberInt1(a, b, r);
        }
        public static function MultiplyNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Multiply, SetLocal(r));
        }
        public static function MultiplyNumberUint10(a:Number, b:uint, r:*):void {
            Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r);
            Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r); Operators.MultiplyNumberUint1(a, b, r);
        }
        //}
        //{ /
        public static function DivideInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Divide, ConvertInt, SetLocal(r));
        }
        public static function DivideInt10(a:int, b:int, r:*):void {
            Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r);
            Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r); Operators.DivideInt1(a, b, r);
        }
        public static function DivideUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Divide, ConvertUInt, SetLocal(r));
        }
        public static function DivideUint10(a:uint, b:uint, r:*):void {
            Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r);
            Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r); Operators.DivideUint1(a, b, r);
        }
        public static function DivideIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Divide, ConvertInt, SetLocal(r));
        }
        public static function DivideIntUint10(a:int, b:uint, r:*):void {
            Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r);
            Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r); Operators.DivideIntUint1(a, b, r);
        }
        public static function DivideNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Divide, SetLocal(r));
        }
        public static function DivideNumber10(a:Number, b:Number, r:*):void {
            Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r);
            Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r); Operators.DivideNumber1(a, b, r);
        }
        public static function DivideNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Divide, SetLocal(r));
        }
        public static function DivideNumberInt10(a:Number, b:int, r:*):void {
            Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r);
            Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r); Operators.DivideNumberInt1(a, b, r);
        }
        public static function DivideNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Divide, SetLocal(r));
        }
        public static function DivideNumberUint10(a:Number, b:uint, r:*):void {
            Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r);
            Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r); Operators.DivideNumberUint1(a, b, r);
        }
        //}
        //{ %
        public static function ModuloInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Modulo, ConvertInt, SetLocal(r));
        }
        public static function ModuloInt10(a:int, b:int, r:*):void {
            Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r);
            Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r); Operators.ModuloInt1(a, b, r);
        }
        public static function ModuloUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Modulo, ConvertUInt, SetLocal(r));
        }
        public static function ModuloUint10(a:uint, b:uint, r:*):void {
            Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r);
            Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r); Operators.ModuloUint1(a, b, r);
        }
        public static function ModuloIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Modulo, ConvertInt, SetLocal(r));
        }
        public static function ModuloIntUint10(a:int, b:uint, r:*):void {
            Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r);
            Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r); Operators.ModuloIntUint1(a, b, r);
        }
        public static function ModuloNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Modulo, SetLocal(r));
        }
        public static function ModuloNumber10(a:Number, b:Number, r:*):void {
            Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r);
            Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r); Operators.ModuloNumber1(a, b, r);
        }
        public static function ModuloNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Modulo, SetLocal(r));
        }
        public static function ModuloNumberInt10(a:Number, b:int, r:*):void {
            Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r);
            Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r); Operators.ModuloNumberInt1(a, b, r);
        }
        public static function ModuloNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Modulo, SetLocal(r));
        }
        public static function ModuloNumberUint10(a:Number, b:uint, r:*):void {
            Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r);
            Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r); Operators.ModuloNumberUint1(a, b, r);
        }
        //}
        //{ <
        public static function LessThanInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessThan, SetLocal(r));
        }
        public static function LessThanInt10(a:int, b:int, r:*):void {
            Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r);
            Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r); Operators.LessThanInt1(a, b, r);
        }
        public static function LessThanUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessThan, SetLocal(r));
        }
        public static function LessThanUint10(a:uint, b:uint, r:*):void {
            Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r);
            Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r); Operators.LessThanUint1(a, b, r);
        }
        public static function LessThanIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessThan, SetLocal(r));
        }
        public static function LessThanIntUint10(a:int, b:uint, r:*):void {
            Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r);
            Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r); Operators.LessThanIntUint1(a, b, r);
        }
        public static function LessThanNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessThan, SetLocal(r));
        }
        public static function LessThanNumber10(a:Number, b:Number, r:*):void {
            Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r);
            Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r); Operators.LessThanNumber1(a, b, r);
        }
        public static function LessThanNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessThan, SetLocal(r));
        }
        public static function LessThanNumberInt10(a:Number, b:int, r:*):void {
            Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r);
            Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r); Operators.LessThanNumberInt1(a, b, r);
        }
        public static function LessThanNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessThan, SetLocal(r));
        }
        public static function LessThanNumberUint10(a:Number, b:uint, r:*):void {
            Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r);
            Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r); Operators.LessThanNumberUint1(a, b, r);
        }
        //}
        //{ <=
        public static function LessEqualsInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessEquals, SetLocal(r));
        }
        public static function LessEqualsInt10(a:int, b:int, r:*):void {
            Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r);
            Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r); Operators.LessEqualsInt1(a, b, r);
        }
        public static function LessEqualsUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessEquals, SetLocal(r));
        }
        public static function LessEqualsUint10(a:uint, b:uint, r:*):void {
            Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r);
            Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r); Operators.LessEqualsUint1(a, b, r);
        }
        public static function LessEqualsIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessEquals, SetLocal(r));
        }
        public static function LessEqualsIntUint10(a:int, b:uint, r:*):void {
            Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r);
            Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r); Operators.LessEqualsIntUint1(a, b, r);
        }
        public static function LessEqualsNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessEquals, SetLocal(r));
        }
        public static function LessEqualsNumber10(a:Number, b:Number, r:*):void {
            Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r);
            Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r); Operators.LessEqualsNumber1(a, b, r);
        }
        public static function LessEqualsNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessEquals, SetLocal(r));
        }
        public static function LessEqualsNumberInt10(a:Number, b:int, r:*):void {
            Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r);
            Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r); Operators.LessEqualsNumberInt1(a, b, r);
        }
        public static function LessEqualsNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), LessEquals, SetLocal(r));
        }
        public static function LessEqualsNumberUint10(a:Number, b:uint, r:*):void {
            Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r);
            Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r); Operators.LessEqualsNumberUint1(a, b, r);
        }
        //}
        //{ >
        public static function GreaterThanInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterThan, SetLocal(r));
        }
        public static function GreaterThanInt10(a:int, b:int, r:*):void {
            Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r);
            Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r); Operators.GreaterThanInt1(a, b, r);
        }
        public static function GreaterThanUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterThan, SetLocal(r));
        }
        public static function GreaterThanUint10(a:uint, b:uint, r:*):void {
            Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r);
            Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r); Operators.GreaterThanUint1(a, b, r);
        }
        public static function GreaterThanIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterThan, SetLocal(r));
        }
        public static function GreaterThanIntUint10(a:int, b:uint, r:*):void {
            Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r);
            Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r); Operators.GreaterThanIntUint1(a, b, r);
        }
        public static function GreaterThanNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterThan, SetLocal(r));
        }
        public static function GreaterThanNumber10(a:Number, b:Number, r:*):void {
            Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r);
            Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r); Operators.GreaterThanNumber1(a, b, r);
        }
        public static function GreaterThanNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterThan, SetLocal(r));
        }
        public static function GreaterThanNumberInt10(a:Number, b:int, r:*):void {
            Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r);
            Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r); Operators.GreaterThanNumberInt1(a, b, r);
        }
        public static function GreaterThanNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterThan, SetLocal(r));
        }
        public static function GreaterThanNumberUint10(a:Number, b:uint, r:*):void {
            Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r);
            Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r); Operators.GreaterThanNumberUint1(a, b, r);
        }
        //}
        //{ >=
        public static function GreaterEqualsInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterEquals, SetLocal(r));
        }
        public static function GreaterEqualsInt10(a:int, b:int, r:*):void {
            Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r);
            Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r); Operators.GreaterEqualsInt1(a, b, r);
        }
        public static function GreaterEqualsUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterEquals, SetLocal(r));
        }
        public static function GreaterEqualsUint10(a:uint, b:uint, r:*):void {
            Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r);
            Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r); Operators.GreaterEqualsUint1(a, b, r);
        }
        public static function GreaterEqualsIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterEquals, SetLocal(r));
        }
        public static function GreaterEqualsIntUint10(a:int, b:uint, r:*):void {
            Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r);
            Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r); Operators.GreaterEqualsIntUint1(a, b, r);
        }
        public static function GreaterEqualsNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterEquals, SetLocal(r));
        }
        public static function GreaterEqualsNumber10(a:Number, b:Number, r:*):void {
            Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r);
            Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r); Operators.GreaterEqualsNumber1(a, b, r);
        }
        public static function GreaterEqualsNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterEquals, SetLocal(r));
        }
        public static function GreaterEqualsNumberInt10(a:Number, b:int, r:*):void {
            Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r);
            Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r); Operators.GreaterEqualsNumberInt1(a, b, r);
        }
        public static function GreaterEqualsNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), GreaterEquals, SetLocal(r));
        }
        public static function GreaterEqualsNumberUint10(a:Number, b:uint, r:*):void {
            Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r);
            Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r); Operators.GreaterEqualsNumberUint1(a, b, r);
        }
        //}
        //{ <<
        public static function ShiftLeftInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftLeft, SetLocal(r));
        }
        public static function ShiftLeftInt10(a:int, b:int, r:*):void {
            Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r);
            Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r); Operators.ShiftLeftInt1(a, b, r);
        }
        public static function ShiftLeftUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftLeft, ConvertUInt, SetLocal(r));
        }
        public static function ShiftLeftUint10(a:uint, b:uint, r:*):void {
            Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r);
            Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r); Operators.ShiftLeftUint1(a, b, r);
        }
        public static function ShiftLeftIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftLeft, SetLocal(r));
        }
        public static function ShiftLeftIntUint10(a:int, b:uint, r:*):void {
            Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r);
            Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r); Operators.ShiftLeftIntUint1(a, b, r);
        }
        public static function ShiftLeftNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftLeft, ConvertDouble, SetLocal(r));
        }
        public static function ShiftLeftNumber10(a:Number, b:Number, r:*):void {
            Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r);
            Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r); Operators.ShiftLeftNumber1(a, b, r);
        }
        public static function ShiftLeftNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftLeft, ConvertDouble, SetLocal(r));
        }
        public static function ShiftLeftNumberInt10(a:Number, b:int, r:*):void {
            Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r);
            Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r); Operators.ShiftLeftNumberInt1(a, b, r);
        }
        public static function ShiftLeftNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftLeft, ConvertDouble, SetLocal(r));
        }
        public static function ShiftLeftNumberUint10(a:Number, b:uint, r:*):void {
            Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r);
            Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r); Operators.ShiftLeftNumberUint1(a, b, r);
        }
        //}
        //{ >>
        public static function ShiftRightInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRight, SetLocal(r));
        }
        public static function ShiftRightInt10(a:int, b:int, r:*):void {
            Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r);
            Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r); Operators.ShiftRightInt1(a, b, r);
        }
        public static function ShiftRightUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRight, ConvertUInt, SetLocal(r));
        }
        public static function ShiftRightUint10(a:uint, b:uint, r:*):void {
            Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r);
            Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r); Operators.ShiftRightUint1(a, b, r);
        }
        public static function ShiftRightIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRight, SetLocal(r));
        }
        public static function ShiftRightIntUint10(a:int, b:uint, r:*):void {
            Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r);
            Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r); Operators.ShiftRightIntUint1(a, b, r);
        }
        public static function ShiftRightNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRight, ConvertDouble, SetLocal(r));
        }
        public static function ShiftRightNumber10(a:Number, b:Number, r:*):void {
            Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r);
            Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r); Operators.ShiftRightNumber1(a, b, r);
        }
        public static function ShiftRightNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRight, ConvertDouble, SetLocal(r));
        }
        public static function ShiftRightNumberInt10(a:Number, b:int, r:*):void {
            Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r);
            Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r); Operators.ShiftRightNumberInt1(a, b, r);
        }
        public static function ShiftRightNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRight, ConvertDouble, SetLocal(r));
        }
        public static function ShiftRightNumberUint10(a:Number, b:uint, r:*):void {
            Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r);
            Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r); Operators.ShiftRightNumberUint1(a, b, r);
        }
        //}
        //{ >>>
        public static function ShiftRightUnsignedInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRightUnsigned, ConvertInt, SetLocal(r));
        }
        public static function ShiftRightUnsignedInt10(a:int, b:int, r:*):void {
            Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r);
            Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r); Operators.ShiftRightUnsignedInt1(a, b, r);
        }
        public static function ShiftRightUnsignedUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRightUnsigned, SetLocal(r));
        }
        public static function ShiftRightUnsignedUint10(a:uint, b:uint, r:*):void {
            Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r);
            Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r); Operators.ShiftRightUnsignedUint1(a, b, r);
        }
        public static function ShiftRightUnsignedIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRightUnsigned, ConvertInt, SetLocal(r));
        }
        public static function ShiftRightUnsignedIntUint10(a:int, b:uint, r:*):void {
            Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r);
            Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r); Operators.ShiftRightUnsignedIntUint1(a, b, r);
        }
        public static function ShiftRightUnsignedNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRightUnsigned, ConvertDouble, SetLocal(r));
        }
        public static function ShiftRightUnsignedNumber10(a:Number, b:Number, r:*):void {
            Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r);
            Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r); Operators.ShiftRightUnsignedNumber1(a, b, r);
        }
        public static function ShiftRightUnsignedNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRightUnsigned, ConvertDouble, SetLocal(r));
        }
        public static function ShiftRightUnsignedNumberInt10(a:Number, b:int, r:*):void {
            Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r);
            Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r); Operators.ShiftRightUnsignedNumberInt1(a, b, r);
        }
        public static function ShiftRightUnsignedNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), ShiftRightUnsigned, ConvertDouble, SetLocal(r));
        }
        public static function ShiftRightUnsignedNumberUint10(a:Number, b:uint, r:*):void {
            Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r);
            Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r); Operators.ShiftRightUnsignedNumberUint1(a, b, r);
        }
        //}
        //{ ==
        public static function EqualsInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, SetLocal(r));
        }
        public static function EqualsInt10(a:int, b:int, r:*):void {
            Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r);
            Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r); Operators.EqualsInt1(a, b, r);
        }
        public static function EqualsUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, SetLocal(r));
        }
        public static function EqualsUint10(a:uint, b:uint, r:*):void {
            Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r);
            Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r); Operators.EqualsUint1(a, b, r);
        }
        public static function EqualsIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, SetLocal(r));
        }
        public static function EqualsIntUint10(a:int, b:uint, r:*):void {
            Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r);
            Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r); Operators.EqualsIntUint1(a, b, r);
        }
        public static function EqualsNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, SetLocal(r));
        }
        public static function EqualsNumber10(a:Number, b:Number, r:*):void {
            Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r);
            Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r); Operators.EqualsNumber1(a, b, r);
        }
        public static function EqualsNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, SetLocal(r));
        }
        public static function EqualsNumberInt10(a:Number, b:int, r:*):void {
            Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r);
            Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r); Operators.EqualsNumberInt1(a, b, r);
        }
        public static function EqualsNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, SetLocal(r));
        }
        public static function EqualsNumberUint10(a:Number, b:uint, r:*):void {
            Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r);
            Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r); Operators.EqualsNumberUint1(a, b, r);
        }
        //}
        //{ ===
        public static function StrictEqualsInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, SetLocal(r));
        }
        public static function StrictEqualsInt10(a:int, b:int, r:*):void {
            Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r);
            Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r); Operators.StrictEqualsInt1(a, b, r);
        }
        public static function StrictEqualsUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, SetLocal(r));
        }
        public static function StrictEqualsUint10(a:uint, b:uint, r:*):void {
            Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r);
            Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r); Operators.StrictEqualsUint1(a, b, r);
        }
        public static function StrictEqualsIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, SetLocal(r));
        }
        public static function StrictEqualsIntUint10(a:int, b:uint, r:*):void {
            Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r);
            Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r); Operators.StrictEqualsIntUint1(a, b, r);
        }
        public static function StrictEqualsNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, SetLocal(r));
        }
        public static function StrictEqualsNumber10(a:Number, b:Number, r:*):void {
            Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r);
            Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r); Operators.StrictEqualsNumber1(a, b, r);
        }
        public static function StrictEqualsNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, SetLocal(r));
        }
        public static function StrictEqualsNumberInt10(a:Number, b:int, r:*):void {
            Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r);
            Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r); Operators.StrictEqualsNumberInt1(a, b, r);
        }
        public static function StrictEqualsNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, SetLocal(r));
        }
        public static function StrictEqualsNumberUint10(a:Number, b:uint, r:*):void {
            Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r);
            Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r); Operators.StrictEqualsNumberUint1(a, b, r);
        }
        //}
        //{ !=
        public static function NotEqualsInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, Not, SetLocal(r));
        }
        public static function NotEqualsInt10(a:int, b:int, r:*):void {
            Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r);
            Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r); Operators.NotEqualsInt1(a, b, r);
        }
        public static function NotEqualsUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, Not, SetLocal(r));
        }
        public static function NotEqualsUint10(a:uint, b:uint, r:*):void {
            Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r);
            Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r); Operators.NotEqualsUint1(a, b, r);
        }
        public static function NotEqualsIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, Not, SetLocal(r));
        }
        public static function NotEqualsIntUint10(a:int, b:uint, r:*):void {
            Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r);
            Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r); Operators.NotEqualsIntUint1(a, b, r);
        }
        public static function NotEqualsNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, Not, SetLocal(r));
        }
        public static function NotEqualsNumber10(a:Number, b:Number, r:*):void {
            Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r);
            Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r); Operators.NotEqualsNumber1(a, b, r);
        }
        public static function NotEqualsNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, Not, SetLocal(r));
        }
        public static function NotEqualsNumberInt10(a:Number, b:int, r:*):void {
            Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r);
            Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r); Operators.NotEqualsNumberInt1(a, b, r);
        }
        public static function NotEqualsNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), Equals, Not, SetLocal(r));
        }
        public static function NotEqualsNumberUint10(a:Number, b:uint, r:*):void {
            Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r);
            Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r); Operators.NotEqualsNumberUint1(a, b, r);
        }
        //}
        //{ !==
        public static function StrictNotEqualsInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, Not, SetLocal(r));
        }
        public static function StrictNotEqualsInt10(a:int, b:int, r:*):void {
            Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r);
            Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r); Operators.StrictNotEqualsInt1(a, b, r);
        }
        public static function StrictNotEqualsUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, Not, SetLocal(r));
        }
        public static function StrictNotEqualsUint10(a:uint, b:uint, r:*):void {
            Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r);
            Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r); Operators.StrictNotEqualsUint1(a, b, r);
        }
        public static function StrictNotEqualsIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, Not, SetLocal(r));
        }
        public static function StrictNotEqualsIntUint10(a:int, b:uint, r:*):void {
            Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r);
            Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r); Operators.StrictNotEqualsIntUint1(a, b, r);
        }
        public static function StrictNotEqualsNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, Not, SetLocal(r));
        }
        public static function StrictNotEqualsNumber10(a:Number, b:Number, r:*):void {
            Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r);
            Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r); Operators.StrictNotEqualsNumber1(a, b, r);
        }
        public static function StrictNotEqualsNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, Not, SetLocal(r));
        }
        public static function StrictNotEqualsNumberInt10(a:Number, b:int, r:*):void {
            Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r);
            Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r); Operators.StrictNotEqualsNumberInt1(a, b, r);
        }
        public static function StrictNotEqualsNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), StrictEquals, Not, SetLocal(r));
        }
        public static function StrictNotEqualsNumberUint10(a:Number, b:uint, r:*):void {
            Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r);
            Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r); Operators.StrictNotEqualsNumberUint1(a, b, r);
        }
        //}
        //{ |
        public static function BitOrInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitOr, SetLocal(r));
        }
        public static function BitOrInt10(a:int, b:int, r:*):void {
            Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r);
            Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r); Operators.BitOrInt1(a, b, r);
        }
        public static function BitOrUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitOr, ConvertUInt, SetLocal(r));
        }
        public static function BitOrUint10(a:uint, b:uint, r:*):void {
            Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r);
            Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r); Operators.BitOrUint1(a, b, r);
        }
        public static function BitOrIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitOr, SetLocal(r));
        }
        public static function BitOrIntUint10(a:int, b:uint, r:*):void {
            Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r);
            Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r); Operators.BitOrIntUint1(a, b, r);
        }
        public static function BitOrNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitOr, ConvertDouble, SetLocal(r));
        }
        public static function BitOrNumber10(a:Number, b:Number, r:*):void {
            Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r);
            Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r); Operators.BitOrNumber1(a, b, r);
        }
        public static function BitOrNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitOr, ConvertDouble, SetLocal(r));
        }
        public static function BitOrNumberInt10(a:Number, b:int, r:*):void {
            Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r);
            Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r); Operators.BitOrNumberInt1(a, b, r);
        }
        public static function BitOrNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitOr, ConvertDouble, SetLocal(r));
        }
        public static function BitOrNumberUint10(a:Number, b:uint, r:*):void {
            Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r);
            Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r); Operators.BitOrNumberUint1(a, b, r);
        }
        //}
        //{ ^
        public static function BitXorInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitXor, SetLocal(r));
        }
        public static function BitXorInt10(a:int, b:int, r:*):void {
            Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r);
            Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r); Operators.BitXorInt1(a, b, r);
        }
        public static function BitXorUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitXor, ConvertUInt, SetLocal(r));
        }
        public static function BitXorUint10(a:uint, b:uint, r:*):void {
            Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r);
            Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r); Operators.BitXorUint1(a, b, r);
        }
        public static function BitXorIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitXor, SetLocal(r));
        }
        public static function BitXorIntUint10(a:int, b:uint, r:*):void {
            Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r);
            Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r); Operators.BitXorIntUint1(a, b, r);
        }
        public static function BitXorNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitXor, ConvertDouble, SetLocal(r));
        }
        public static function BitXorNumber10(a:Number, b:Number, r:*):void {
            Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r);
            Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r); Operators.BitXorNumber1(a, b, r);
        }
        public static function BitXorNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitXor, ConvertDouble, SetLocal(r));
        }
        public static function BitXorNumberInt10(a:Number, b:int, r:*):void {
            Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r);
            Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r); Operators.BitXorNumberInt1(a, b, r);
        }
        public static function BitXorNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitXor, ConvertDouble, SetLocal(r));
        }
        public static function BitXorNumberUint10(a:Number, b:uint, r:*):void {
            Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r);
            Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r); Operators.BitXorNumberUint1(a, b, r);
        }
        //}
        //{ &
        public static function BitAndInt1(a:int, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitAnd, SetLocal(r));
        }
        public static function BitAndInt10(a:int, b:int, r:*):void {
            Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r);
            Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r); Operators.BitAndInt1(a, b, r);
        }
        public static function BitAndUint1(a:uint, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitAnd, ConvertUInt, SetLocal(r));
        }
        public static function BitAndUint10(a:uint, b:uint, r:*):void {
            Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r);
            Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r); Operators.BitAndUint1(a, b, r);
        }
        public static function BitAndIntUint1(a:int, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitAnd, SetLocal(r));
        }
        public static function BitAndIntUint10(a:int, b:uint, r:*):void {
            Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r);
            Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r); Operators.BitAndIntUint1(a, b, r);
        }
        public static function BitAndNumber1(a:Number, b:Number, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitAnd, ConvertDouble, SetLocal(r));
        }
        public static function BitAndNumber10(a:Number, b:Number, r:*):void {
            Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r);
            Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r); Operators.BitAndNumber1(a, b, r);
        }
        public static function BitAndNumberInt1(a:Number, b:int, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitAnd, ConvertDouble, SetLocal(r));
        }
        public static function BitAndNumberInt10(a:Number, b:int, r:*):void {
            Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r);
            Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r); Operators.BitAndNumberInt1(a, b, r);
        }
        public static function BitAndNumberUint1(a:Number, b:uint, r:*):void {
            __asm(GetLocal(a), GetLocal(b), BitAnd, ConvertDouble, SetLocal(r));
        }
        public static function BitAndNumberUint10(a:Number, b:uint, r:*):void {
            Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r);
            Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r); Operators.BitAndNumberUint1(a, b, r);
        }
        //}
        //{ =
        public static function EqualInt1(a:int, b:int):void {
            __asm(GetLocal(b), ConvertInt, SetLocal(a));
        }
        public static function EqualInt10(a:int, b:int):void {
            Operators.EqualInt1(a, b); Operators.EqualInt1(a, b); Operators.EqualInt1(a, b); Operators.EqualInt1(a, b); Operators.EqualInt1(a, b);
            Operators.EqualInt1(a, b); Operators.EqualInt1(a, b); Operators.EqualInt1(a, b); Operators.EqualInt1(a, b); Operators.EqualInt1(a, b);
        }
        public static function EqualUint1(a:uint, b:uint):void {
            __asm(GetLocal(b), ConvertUInt, SetLocal(a));
        }
        public static function EqualUint10(a:uint, b:uint):void {
            Operators.EqualUint1(a, b); Operators.EqualUint1(a, b); Operators.EqualUint1(a, b); Operators.EqualUint1(a, b); Operators.EqualUint1(a, b);
            Operators.EqualUint1(a, b); Operators.EqualUint1(a, b); Operators.EqualUint1(a, b); Operators.EqualUint1(a, b); Operators.EqualUint1(a, b);
        }
        public static function EqualIntUint1(a:int, b:uint):void {
            __asm(GetLocal(b), ConvertInt, SetLocal(a));
        }
        public static function EqualIntUint10(a:int, b:uint):void {
            Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b);
            Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b); Operators.EqualIntUint1(a, b);
        }
        public static function EqualNumber1(a:Number, b:Number):void {
            __asm(GetLocal(b), ConvertDouble, SetLocal(a));
        }
        public static function EqualNumber10(a:Number, b:Number):void {
            Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b);
            Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b); Operators.EqualNumber1(a, b);
        }
        public static function EqualNumberInt1(a:Number, b:int):void {
            __asm(GetLocal(b), ConvertDouble, SetLocal(a));
        }
        public static function EqualNumberInt10(a:Number, b:int):void {
            Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b);
            Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b); Operators.EqualNumberInt1(a, b);
        }
        public static function EqualNumberUint1(a:Number, b:uint):void {
            __asm(GetLocal(b), ConvertDouble, SetLocal(a));
        }
        public static function EqualNumberUint10(a:Number, b:uint):void {
            Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b);
            Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b); Operators.EqualNumberUint1(a, b);
        }
        //}
        //{ !
        public static function NotInt1(a:*, b:int):void {
            __asm(GetLocal(b), Not, SetLocal(a));
        }
        public static function NotInt10(a:*, b:int):void {
            Operators.NotInt1(a, b); Operators.NotInt1(a, b); Operators.NotInt1(a, b); Operators.NotInt1(a, b); Operators.NotInt1(a, b);
            Operators.NotInt1(a, b); Operators.NotInt1(a, b); Operators.NotInt1(a, b); Operators.NotInt1(a, b); Operators.NotInt1(a, b);
        }
        public static function NotUint1(a:*, b:uint):void {
            __asm(GetLocal(b), Not, SetLocal(a));
        }
        public static function NotUint10(a:*, b:uint):void {
            Operators.NotUint1(a, b); Operators.NotUint1(a, b); Operators.NotUint1(a, b); Operators.NotUint1(a, b); Operators.NotUint1(a, b);
            Operators.NotUint1(a, b); Operators.NotUint1(a, b); Operators.NotUint1(a, b); Operators.NotUint1(a, b); Operators.NotUint1(a, b);
        }
        public static function NotNumber1(a:*, b:Number):void {
            __asm(GetLocal(b), Not, SetLocal(a));
        }
        public static function NotNumber10(a:*, b:Number):void {
            Operators.NotNumber1(a, b); Operators.NotNumber1(a, b); Operators.NotNumber1(a, b); Operators.NotNumber1(a, b); Operators.NotNumber1(a, b);
            Operators.NotNumber1(a, b); Operators.NotNumber1(a, b); Operators.NotNumber1(a, b); Operators.NotNumber1(a, b); Operators.NotNumber1(a, b);
        }
        //}
        //{ ~
        public static function BitNotInt1(a:*, b:int):void {
            __asm(GetLocal(b), BitNot, SetLocal(a));
        }
        public static function BitNotInt10(a:*, b:int):void {
            Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b);
            Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b); Operators.BitNotInt1(a, b);
        }
        public static function BitNotUint1(a:*, b:uint):void {
            __asm(GetLocal(b), BitNot, ConvertUInt, SetLocal(a));
        }
        public static function BitNotUint10(a:*, b:uint):void {
            Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b);
            Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b); Operators.BitNotUint1(a, b);
        }
        public static function BitNotNumber1(a:*, b:Number):void {
            __asm(GetLocal(b), BitNot, ConvertDouble, SetLocal(a));
        }
        public static function BitNotNumber10(a:*, b:Number):void {
            Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b);
            Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b); Operators.BitNotNumber1(a, b);
        }
        //}
        //{ ++
        public static function IncrementInt1(a:int, r:int):void {
            __asm(GetLocal(a), IncrementInt, SetLocal(r));
        }
        public static function IncrementInt10(a:int, r:int):void {
            Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r);
            Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r); Operators.IncrementInt1(a, r);
        }
        public static function IncrementUint1(a:uint, r:uint):void {
            __asm(GetLocal(a), IncrementInt, ConvertUInt, SetLocal(r));
        }
        public static function IncrementUint10(a:uint, r:uint):void {
            Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r);
            Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r); Operators.IncrementUint1(a, r);
        }
        public static function IncrementNumber1(a:Number, r:Number):void {
            __asm(GetLocal(a), Increment, SetLocal(r));
        }
        public static function IncrementNumber10(a:Number, r:Number):void {
            Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r);
            Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r); Operators.IncrementNumber1(a, r);
        }
        //}
        //{ --
        public static function DecrementInt1(a:int, r:*):void {
            __asm(GetLocal(a), DecrementInt, SetLocal(r));
        }
        public static function DecrementInt10(a:int, r:*):void {
            Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r);
            Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r); Operators.DecrementInt1(a, r);
        }
        public static function DecrementUint1(a:uint, r:*):void {
            __asm(GetLocal(a), DecrementInt, ConvertUInt, SetLocal(r));
        }
        public static function DecrementUint10(a:uint, r:*):void {
            Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r);
            Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r); Operators.DecrementUint1(a, r);
        }
        public static function DecrementNumber1(a:Number, r:*):void {
            __asm(GetLocal(a), Decrement, SetLocal(r));
        }
        public static function DecrementNumber10(a:Number, r:*):void {
            Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r);
            Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r); Operators.DecrementNumber1(a, r);
        }
        //}
        //{ IncLocal
        public static function IncLocalInt1(a:int):void {
            __asm(IncLocalInt(a));
        }
        public static function IncLocalInt10(a:int):void {
            Operators.IncLocalInt1(a); Operators.IncLocalInt1(a); Operators.IncLocalInt1(a); Operators.IncLocalInt1(a); Operators.IncLocalInt1(a);
            Operators.IncLocalInt1(a); Operators.IncLocalInt1(a); Operators.IncLocalInt1(a); Operators.IncLocalInt1(a); Operators.IncLocalInt1(a);
        }
        public static function IncLocalNumber1(a:Number):void {
            __asm(IncLocal(a));
        }
        public static function IncLocalNumber10(a:Number):void {
            Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a);
            Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a); Operators.IncLocalNumber1(a);
        }
        //}
        //{ DecLocal
        public static function DecLocalInt1(a:int):void {
            __asm(DecLocalInt(a));
        }
        public static function DecLocalInt10(a:int):void {
            Operators.DecLocalInt1(a); Operators.DecLocalInt1(a); Operators.DecLocalInt1(a); Operators.DecLocalInt1(a); Operators.DecLocalInt1(a);
            Operators.DecLocalInt1(a); Operators.DecLocalInt1(a); Operators.DecLocalInt1(a); Operators.DecLocalInt1(a); Operators.DecLocalInt1(a);
        }
        public static function DecLocalNumber1(a:Number):void {
            __asm(DecLocal(a));
        }
        public static function DecLocalNumber10(a:Number):void {
            Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a);
            Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a); Operators.DecLocalNumber1(a);
        }
        //}
    }