Upgraded Type Analysis

2024-06-16 13:10:14 +10:00
1 parent 30a614dfc4
commit fffb72b09d
@@ -1,13 +1,16 @@
+// @ts-check
+
 const BlockUtility = require('../engine/block-utility');

 class CompatibilityLayerBlockUtility extends BlockUtility {
    constructor () {
        super();
+        this._stackFrame = {};
        this._startedBranch = null;
    }

    get stackFrame () {
-        return this.thread.compatibilityStackFrame;
+        return this._stackFrame;
    }

    startBranch (branchNumber, isLoop) {
@@ -32,9 +35,9 @@ class CompatibilityLayerBlockUtility extends BlockUtility {
    init (thread, fakeBlockId, stackFrame) {
        this.thread = thread;
        this.sequencer = thread.target.runtime.sequencer;
+        this._stackFrame = stackFrame;
        this._startedBranch = null;
        thread.stack[0] = fakeBlockId;
-        thread.compatibilityStackFrame = stackFrame;
    }
 }

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
 * @fileoverview List of blocks to be supported in the compiler compatibility layer.
 * This is only for native blocks. Extensions should not be listed here.
@@ -1,14 +1,20 @@
-const {IRGenerator} = require('./irgen');
+// @ts-check
+
+const IRGenerator = require('./irgen');
+const {IROptimizer} = require('./iroptimizer');
 const JSGenerator = require('./jsgen');

-const compile = thread => {
+const compile = (/** @type {import("../engine/thread")} */ thread) => {
    const irGenerator = new IRGenerator(thread);
    const ir = irGenerator.generate();

+    const irOptimizer = new IROptimizer(ir);
+    irOptimizer.optimize();
+
    const procedures = {};
    const target = thread.target;

-    const compileScript = script => {
+    const compileScript = (/** @type {import("./intermediate").IntermediateScript} */ script) => {
        if (script.cachedCompileResult) {
            return script.cachedCompileResult;
        }
@@ -0,0 +1,295 @@
+// @ts-check
+
+/**
+ * @fileoverview Common enums shared amongst parts of the compiler.
+ */
+
+
+/**
+ * Enum for the type of the value that is returned by reporter blocks and stored in constants.
+ *
+ * At compile time, often we don't know exactly type a value will be but we can tell it must be one of a
+ * set of types. For this reason, the number value of each type represents a possibility space, where set
+ * bits indicate that their corropoding type *could* be encountered at runtime.
+ * For example, a type of InputType.NUMBER | InputType.STRING means the value will be either a number or
+ * a string at runtime, the compiler can't tell which, but we do know that it's not a boolean or NaN as
+ * those bits are not set.
+ *
+ * @readonly
+ * @enum {number}
+ */
+const InputType = {
+    /** The value Infinity */
+    NUMBER_POS_INF: 0x001,
+    /** Any natural number */
+    NUMBER_POS_INT: 0x002,
+    /** Any positive fractional number, excluding integers. */
+    NUMBER_POS_FRACT: 0x004,
+    /** Any positive number excluding 0 and Infinity. Equal to NUMBER_POS_INT | NUMBER_POS_FRACT */
+    NUMBER_POS_REAL: 0x006,
+    /** The value 0 */
+    NUMBER_ZERO: 0x008,
+    /** The value -0 */
+    NUMBER_NEG_ZERO: 0x010,
+    /** Any negitive integer excluding -0 */
+    NUMBER_NEG_INT: 0x020,
+    /** Any negitive fractional number, excluding integers. */
+    NUMBER_NEG_FRACT: 0x040,
+    /** Any negitive number excluding -0 and -Infinity. Equal to NUMBER_NEG_INT | NUMBER_NEG_FRACT */
+    NUMBER_NEG_REAL: 0x060,
+    /** The value -Infinity */
+    NUMBER_NEG_INF: 0x080,
+
+    /** The value NaN */
+    NUMBER_NAN: 0x100,
+
+    /** Either 0 or -0. Equal to NUMBER_ZERO | NUMBER_NEG_ZERO */
+    NUMBER_ANY_ZERO: 0x018,
+    /** Either Infinity or -Infinity. Equal to NUMBER_POS_INF | NUMBER_NEG_INF */
+    NUMBER_INF: 0x081,
+    /** Any positive number, excluding 0. Equal to NUMBER_POS_REAL | NUMBER_POS_INF */
+    NUMBER_POS: 0x007,
+    /** Any negitive number, excluding -0. Equal to NUMBER_NEG_REAL | NUMBER_NEG_INF */
+    NUMBER_NEG: 0x0E0,
+    /** Any whole number. Equal to NUMBER_POS_INT | NUMBER_ZERO */
+    NUMBER_WHOLE: 0x00A,
+    /** Any integer. Equal to NUMBER_POS_INT | NUMBER_ANY_ZERO | NUMBER_NEG_INT */
+    NUMBER_INT: 0x03A,
+    /** Any number that works as an array index. Equal to NUMBER_INT | NUMBER_INF | NUMBER_NAN */
+    NUMBER_INDEX: 0x1BB,
+    /** Any fractional non-integer numbers. Equal to NUMBER_POS_FRACT | NUMBER_NEG_FRACT */
+    NUMBER_FRACT: 0x44,
+    /** Any real number. Equal to NUMBER_POS_REAL | NUMBER_ANY_ZERO | NUMBER_NEG_REAL */
+    NUMBER_REAL: 0x07E,
+
+    /** Any number, excluding NaN. Equal to NUMBER_REAL | NUMBER_INF */
+    NUMBER: 0x0FF,
+    /** Any number, including NaN. Equal to NUMBER | NUMBER_NAN */
+    NUMBER_OR_NAN: 0x1FF,
+    /** Anything that can be interperated as a number. Equal to NUMBER | STRING_NUM | BOOLEAN */
+    NUMBER_INTERPRETABLE: 0x12FF,
+
+    /** Any string which as a non-NaN neumeric interpretation, excluding ''.  */
+    STRING_NUM: 0x200,
+    /** Any string which has no non-NaN neumeric interpretation, including ''. */
+    STRING_NAN: 0x400,
+    /** Either of the strings 'true' or 'false'. */
+    STRING_BOOLEAN: 0x800,
+
+    /** Any string. Equal to STRING_NUM | STRING_NAN | STRING_BOOLEAN */
+    STRING: 0xE00,
+
+    /** Any boolean. */
+    BOOLEAN: 0x1000,
+    /** Any input that can be interperated as a boolean. Equal to BOOLEAN | STRING_BOOLEAN */
+    BOOLEAN_INTERPRETABLE: 0x1800,
+
+    /** Any type. Equal to NUMBER_OR_NAN | STRING | BOOLEAN */
+    ANY: 0x1FFF
+};
+
+/**
+ * Enum for the opcodes of the stackable blocks used in the IR AST.
+ * @readonly
+ * @enum {string}
+ */
+const StackOpcode = {
+    NOP: 'noop',
+
+    ADDON_CALL: 'addons.call',
+    DEBUGGER: 'tw.debugger',
+    VISUAL_REPORT: 'visualReport',
+    COMPATIBILITY_LAYER: 'compat',
+
+    HAT_EDGE: 'hat.edge',
+    HAT_PREDICATE: 'hat.predicate',
+
+    CONTROL_IF_ELSE: 'control.if',
+    CONTROL_CLONE_CREATE: 'control.createClone',
+    CONTROL_CLONE_DELETE: 'control.deleteClone',
+    CONTROL_WHILE: 'control.while',
+    CONTROL_FOR: 'control.for',
+    CONTROL_REPEAT: 'control.repeat',
+    CONTROL_STOP_ALL: 'control.stopAll',
+    CONTROL_STOP_OTHERS: 'control.stopOthers',
+    CONTROL_STOP_SCRIPT: 'control.stopScript',
+    CONTROL_WAIT: 'control.wait',
+    CONTROL_WAIT_UNTIL: 'control.waitUntil',
+    CONTROL_CLEAR_COUNTER: 'control.counterClear',
+    CONTORL_INCR_COUNTER: 'control.counterIncr',
+
+    LIST_ADD: 'list.add',
+    LIST_INSERT: 'list.instert',
+    LIST_REPLACE: 'list.replace',
+    LIST_DELETE_ALL: 'list.deleteAll',
+    LIST_DELETE: 'list.delete',
+    LIST_SHOW: 'list.show',
+    LIST_HIDE: 'list.hide',
+
+    VAR_SET: 'var.set',
+    VAR_SHOW: 'var.show',
+    VAR_HIDE: 'var.hide',
+
+    EVENT_BROADCAST: 'event.broadcast',
+    EVENT_BROADCAST_AND_WAIT: 'event.broadcastAndWait',
+
+    LOOKS_EFFECT_SET: 'looks.setEffect',
+    LOOKS_EFFECT_CHANGE: 'looks.changeEffect',
+    LOOKS_EFFECT_CLEAR: 'looks.clearEffects',
+    LOOKS_SIZE_CHANGE: 'looks.changeSize',
+    LOOKS_SIZE_SET: 'looks.setSize',
+    LOOKS_LAYER_FORWARD: 'looks.forwardLayers',
+    LOOKS_LAYER_BACKWARD: 'looks.backwardLayers',
+    LOOKS_LAYER_FRONT: 'looks.goToFront',
+    LOOKS_LAYER_BACK: 'looks.goToBack',
+    LOOKS_HIDE: 'looks.hide',
+    LOOKS_SHOW: 'looks.show',
+    LOOKS_BACKDROP_NEXT: 'looks.nextBackdrop',
+    LOOKS_BACKDROP_SET: 'looks.switchBackdrop',
+    LOOKS_COSTUME_NEXT: 'looks.nextCostume',
+    LOOKS_COSTUME_SET: 'looks.switchCostume',
+
+    MOTION_X_SET: 'motion.setX',
+    MOTION_X_CHANGE: 'motion.changeX',
+    MOTION_Y_SET: 'motion.setY',
+    MOTION_Y_CHANGE: 'motion.changeY',
+    MOTION_XY_SET: 'motion.setXY',
+    MOTION_IF_ON_EDGE_BOUNCE: 'motion.ifOnEdgeBounce',
+    MOTION_STEP: 'motion.step',
+    MOTION_ROTATION_STYLE_SET: 'motion.setRotationStyle',
+    MOTION_DIRECTION_SET: 'motion.setDirection',
+
+    PEN_UP: 'pen.up',
+    PEN_DOWN: 'pen.down',
+    PEN_CLEAR: 'pen.clear',
+    PEN_COLOR_PARAM_SET: 'pen.setParam',
+    PEN_COLOR_PARAM_CHANGE: 'pen.changeParam',
+    PEN_COLOR_HUE_CHANGE_LEGACY: 'pen.legacyChangeHue',
+    PEN_COLOR_HUE_SET_LEGACY: 'pen_setPenHueToNumber',
+    PEN_COLOR_SHADE_CHANGE_LEGACY: 'pen.legacyChangeShade',
+    PEN_COLOR_SHADE_SET_LEGACY: 'pen.legacySetShade',
+    PEN_COLOR_SET: 'pen.setColor',
+    PEN_SIZE_SET: 'pen.setSize',
+    PEN_SIZE_CHANGE: 'pen.changeSize',
+    PEN_STAMP: 'pen.stamp',
+
+    SENSING_TIMER_RESET: 'timer.reset',
+
+    PROCEDURE_RETURN: 'procedures.return',
+    PROCEDURE_CALL: 'procedures.call'
+};
+
+/**
+ * Enum for the opcodes of the reporter blocks used in the IR AST.
+ * @readonly
+ * @enum {string}
+ */
+const InputOpcode = {
+    NOP: 'noop',
+
+    ADDON_CALL: 'addons.call',
+    CONSTANT: 'constant',
+
+    CAST_NUMBER: 'cast.toNumber',
+    CAST_NUMBER_INDEX: 'cast.toInteger',
+    CAST_NUMBER_OR_NAN: 'cast.toNumberOrNaN',
+    CAST_STRING: 'cast.toString',
+    CAST_BOOLEAN: 'cast.toBoolean',
+
+    COMPATIBILITY_LAYER: 'compat',
+
+    LOOKS_BACKDROP_NUMBER: 'looks.backdropNumber',
+    LOOKS_BACKDROP_NAME: 'looks.backdropName',
+    LOOKS_COSTUME_NUMBER: 'looks.costumeNumber',
+    LOOKS_COSTUME_NAME: 'looks.costumeName',
+    LOOKS_SIZE_GET: 'looks.size',
+
+    VAR_GET: 'var.get',
+
+    LIST_GET: 'list.get',
+    LIST_LENGTH: 'list.length',
+    LIST_CONTAINS: 'list.contains',
+    LIST_INDEX_OF: 'list.indexOf',
+    LIST_CONTENTS: 'list.contents',
+
+    MOTION_X_GET: 'motion.x',
+    MOTION_Y_GET: 'motion.y',
+    MOTION_DIRECTION_GET: 'motion.direction',
+
+    OP_ADD: 'op.add',
+    OP_AND: 'op.and',
+    OP_CONTAINS: 'op.contains',
+    OP_DIVIDE: 'op.divide',
+    OP_EQUALS: 'op.equals',
+    OP_GREATER: 'op.greater',
+    OP_LESS: 'op.less',
+    OP_JOIN: 'op.join',
+    OP_LENGTH: 'op.length',
+    OP_LETTER_OF: 'op.letterOf',
+    OP_ABS: 'op.abs',
+    OP_FLOOR: 'op.floor',
+    OP_CEILING: 'op.ceiling',
+    OP_SQRT: 'op.sqrt',
+    OP_SIN: 'op.sin',
+    OP_COS: 'op.cos',
+    OP_TAN: 'op.tan',
+    OP_ASIN: 'op.asin',
+    OP_ACOS: 'op.acos',
+    OP_ATAN: 'op.atan',
+    OP_LOG_E: 'op.ln',
+    OP_LOG_10: 'op.log',
+    OP_POW_E: 'op.e^',
+    OP_POW_10: 'op.10^',
+    OP_MOD: 'op.mod',
+    OP_MULTIPLY: 'op.multiply',
+    OP_NOT: 'op.not',
+    OP_OR: 'op.or',
+    OP_RANDOM: 'op.random',
+    OP_ROUND: 'op.round',
+    OP_SUBTRACT: 'op.subtract',
+
+    SENSING_ANSWER: 'sensing.answer',
+    SENSING_COLOR_TOUCHING_COLOR: 'sensing.colorTouchingColor',
+    SENSING_TIME_YEAR: 'sensing.year',
+    SENSING_TIME_MONTH: 'sensing.month',
+    SENSING_TIME_DATE: 'sensing.date',
+    SENSING_TIME_WEEKDAY: 'sensing.dayofweek',
+    SENSING_TIME_HOUR: 'sensing.hour',
+    SENSING_TIME_MINUTE: 'sensing.minute',
+    SENSING_TIME_SECOND: 'sensing.second',
+    SENSING_TIME_DAYS_SINCE_2000: 'sensing.daysSince2000',
+    SENSING_DISTANCE: 'sensing.distance',
+    SENSING_KEY_DOWN: 'keyboard.pressed',
+    SENSING_MOUSE_DOWN: 'mouse.down',
+    SENSING_MOUSE_X: 'mouse.x',
+    SENSING_MOUSE_Y: 'mouse.y',
+    SENSING_OF: 'sensing.of',
+    SENSING_OF_BACKDROP_NAME: 'sensing.of.backdropName',
+    SENSING_OF_BACKDROP_NUMBER: 'sensing.of.backdropNumber',
+    SENSING_OF_COSTUME_NAME: 'sensing.of.costumeName',
+    SENSING_OF_COSTUME_NUMBER: 'sensing.of.costumeNumber',
+    SENSING_OF_VOLUME: 'sensing.of.volume',
+    SENSING_OF_POS_X: 'sensing.of.x',
+    SENSING_OF_POS_Y: 'sensing.of.y',
+    SENSING_OF_DIRECTION: 'sensing.of.direction',
+    SENSING_OF_SIZE: 'sensing.of.size',
+    SENSING_OF_VAR: 'sensing.of.var',
+    SENSING_TIMER_GET: 'timer.get',
+    SENSING_TOUCHING_COLOR: 'sensing.touchingColor',
+    SENSING_TOUCHING_OBJECT: 'sensing.touching',
+    SENSING_USERNAME: 'sensing.username',
+
+    PROCEDURE_CALL: 'procedures.call',
+    PROCEDURE_ARG_STRING_NUMBER: 'args.stringNumber',
+    PROCEDURE_ARG_BOOLEAN: 'args.boolean',
+
+    CONTROL_COUNTER: 'control.counter',
+
+    TW_KEY_LAST_PRESSED: 'tw.lastKeyPressed'
+};
+
+module.exports = {
+    StackOpcode,
+    InputOpcode,
+    InputType
+};
@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable no-eval */

 /**
@@ -1,7 +1,220 @@
+// @ts-check
+
+const Cast = require('../util/cast');
+const {InputOpcode, InputType} = require('./enums.js');
+const log = require('../util/log');
+
 /**
 * @fileoverview Common intermediates shared amongst parts of the compiler.
 */

+/**
+ * Describes a 'stackable' block (eg. show)
+ */
+class IntermediateStackBlock {
+    /**
+     * @param {import("./enums").StackOpcode} opcode
+     * @param {Object} inputs
+     * @param {boolean} yields
+     */
+    constructor (opcode, inputs = {}, yields = false) {
+        /**
+         * The type of the stackable block.
+         * @type {import("./enums").StackOpcode}
+         */
+        this.opcode = opcode;
+
+        /**
+         * The inputs of this block.
+         * @type {Object}
+         */
+        this.inputs = inputs;
+
+        /**
+         * Does this block cause a yield
+         * @type {boolean}
+         */
+        this.yields = yields;
+
+        /**
+         * Should state changes made by this stack block be ignored? Used for testing.
+         * @type {boolean}
+         */
+        this.ignoreState = false;
+
+        /**
+         * @type {import("./iroptimizer").TypeState?}
+         */
+        this.entryState = null;
+
+        /**
+         * @type {import("./iroptimizer").TypeState?}
+         */
+        this.exitState = null;
+    }
+}
+
+/**
+ * Describes an input to a block.
+ * This could be a constant, variable or math operation.
+ */
+class IntermediateInput {
+
+    static getNumberInputType (number) {
+        if (typeof number !== 'number') throw new Error('Expected a number.');
+        if (number === Infinity) return InputType.NUMBER_POS_INF;
+        if (number === -Infinity) return InputType.NUMBER_NEG_INF;
+        if (number < 0) return Number.isInteger(number) ? InputType.NUMBER_NEG_INT : InputType.NUMBER_NEG_FRACT;
+        if (number > 0) return Number.isInteger(number) ? InputType.NUMBER_POS_INT : InputType.NUMBER_POS_FRACT;
+        if (Number.isNaN(number)) return InputType.NUMBER_NAN;
+        if (Object.is(number, -0)) return InputType.NUMBER_NEG_ZERO;
+        return InputType.NUMBER_ZERO;
+    }
+
+    /**
+     * @param {InputOpcode} opcode
+     * @param {InputType} type
+     * @param {Object} inputs
+     * @param {boolean} yields
+     */
+    constructor (opcode, type, inputs = {}, yields = false) {
+        /**
+         * @type {InputOpcode}
+         */
+        this.opcode = opcode;
+
+        /**
+         * @type {InputType}
+         */
+        this.type = type;
+
+        /**
+         * @type {Object}
+         */
+        this.inputs = inputs;
+
+        /**
+         * @type {boolean}
+         */
+        this.yields = yields;
+    }
+
+    /**
+     * Is this input a constant whos value equals value.
+     * @param {*} value The value
+     * @returns {boolean}
+     */
+    isConstant (value) {
+        if (this.opcode !== InputOpcode.CONSTANT) return false;
+        let equal = this.inputs.value === value;
+        if (!equal && typeof value === 'number') equal = (+this.inputs.value) === value;
+        return equal;
+    }
+
+    /**
+     * Is the type of this input guaranteed to always be the type at runtime.
+     * @param {InputType} type
+     * @returns {boolean}
+     */
+    isAlwaysType (type) {
+        return (this.type & type) === this.type;
+    }
+
+    /**
+     * Is it possible for this input to be the type at runtime.
+     * @param {InputType} type
+     * @returns
+     */
+    isSometimesType (type) {
+        return (this.type & type) !== 0;
+    }
+
+    /**
+     * Converts this input to a target type.
+     * If this input is a constant the conversion is performed now, at compile time.
+     * If the input changes, the conversion is performed at runtime.
+     * @param {InputType} targetType
+     * @returns {IntermediateInput} An input with the new type.
+     */
+    toType (targetType) {
+        let castOpcode;
+        switch (targetType) {
+        case InputType.BOOLEAN:
+            castOpcode = InputOpcode.CAST_BOOLEAN;
+            break;
+        case InputType.NUMBER:
+            castOpcode = InputOpcode.CAST_NUMBER;
+            break;
+        case InputType.NUMBER_INDEX:
+            castOpcode = InputOpcode.CAST_NUMBER_INDEX;
+            break;
+        case InputType.NUMBER_OR_NAN:
+            castOpcode = InputOpcode.CAST_NUMBER_OR_NAN;
+            break;
+        case InputType.STRING:
+            castOpcode = InputOpcode.CAST_STRING;
+            break;
+        default:
+            log.warn(`Cannot cast to type: ${targetType}`, this);
+            throw new Error(`Cannot cast to type: ${targetType}`);
+        }
+
+        if (this.isAlwaysType(targetType)) return this;
+
+        if (this.opcode === InputOpcode.CONSTANT) {
+            // If we are a constant, we can do the cast here at compile time
+            switch (castOpcode) {
+            case InputOpcode.CAST_BOOLEAN:
+                this.inputs.value = Cast.toBoolean(this.inputs.value);
+                this.type = InputType.BOOLEAN;
+                break;
+            case InputOpcode.CAST_NUMBER:
+            case InputOpcode.CAST_NUMBER_INDEX:
+            case InputOpcode.CAST_NUMBER_OR_NAN:
+                if (this.isAlwaysType(InputType.BOOLEAN_INTERPRETABLE)) {
+                    this.type = InputType.NUMBER;
+                    this.inputs.value = +Cast.toBoolean(this.inputs.value);
+                }
+                var numberValue = +this.inputs.value;
+                if (numberValue) {
+                    this.inputs.value = numberValue;
+                } else {
+                    // numberValue is one of 0, -0, or NaN
+                    if (Object.is(numberValue, -0)) this.inputs.value = -0;
+                    else this.inputs.value = 0; // Convert NaN to 0
+                }
+                if (castOpcode === InputOpcode.CAST_NUMBER_INDEX) {
+                    // Round numberValue to an integer
+                    numberValue |= 0;
+                }
+                this.type = IntermediateInput.getNumberInputType(this.inputs.value);
+                break;
+            case InputOpcode.CAST_STRING:
+                this.inputs.value += '';
+                this.type = InputType.STRING;
+                break;
+            }
+            return this;
+        }
+
+        return new IntermediateInput(castOpcode, targetType, {target: this});
+    }
+}
+
+/**
+ * A 'stack' of blocks, like the contents of a script or the inside
+ * of a C block.
+ */
+class IntermediateStack {
+    /**
+     * @param {IntermediateStackBlock[]} [blocks]
+     */
+    constructor (blocks) {
+        /** @type {IntermediateStackBlock[]} */
+        this.blocks = blocks ?? [];
+    }
+}
+
 /**
 * An IntermediateScript describes a single script.
 * Scripts do not necessarily have hats.
@@ -10,13 +223,13 @@ class IntermediateScript {
    constructor () {
        /**
         * The ID of the top block of this script.
-         * @type {string}
+         * @type {string?}
         */
        this.topBlockId = null;

        /**
         * List of nodes that make up this script.
-         * @type {Array|null}
+         * @type {IntermediateStack?}
         */
        this.stack = null;

@@ -26,12 +239,6 @@ class IntermediateScript {
         */
        this.isProcedure = false;

-        /**
-         * This procedure's variant, if any.
-         * @type {string}
-         */
-        this.procedureVariant = '';
-
        /**
         * This procedure's code, if any.
         * @type {string}
@@ -76,11 +283,18 @@ class IntermediateScript {
         */
        this.cachedCompileResult = null;

+        /**
+         * Cached result of analysing this script.
+         * @type {import("./iroptimizer").TypeState|null}
+         */
+        this.cachedAnalysisEndState = null;
+
        /**
         * Whether the top block of this script is an executable hat.
         * @type {boolean}
         */
        this.executableHat = false;
+
    }
 }

@@ -88,22 +302,39 @@ class IntermediateScript {
 * An IntermediateRepresentation contains scripts.
 */
 class IntermediateRepresentation {
-    constructor () {
+    /**
+     *
+     * @param {IntermediateScript} entry
+     * @param {Object.<string, IntermediateScript>} procedures
+     */
+    constructor (entry, procedures) {
        /**
         * The entry point of this IR.
         * @type {IntermediateScript}
         */
-        this.entry = null;
+        this.entry = entry;

        /**
         * Maps procedure variants to their intermediate script.
         * @type {Object.<string, IntermediateScript>}
         */
-        this.procedures = {};
+        this.procedures = procedures;
+    }
+
+    /**
+     * Gets the first procedure with the given proccode.
+     * @param {string} proccode
+     * @returns {IntermediateScript | undefined}
+     */
+    getProcedure (proccode) {
+        return Object.values(this.procedures).find(procedure => procedure.procedureCode === proccode);
    }
 }

 module.exports = {
+    IntermediateStackBlock,
+    IntermediateInput,
+    IntermediateStack,
    IntermediateScript,
    IntermediateRepresentation
 };
@@ -0,0 +1,703 @@
+// @ts-check
+
+const {IntermediateStack, IntermediateInput, IntermediateScript, IntermediateRepresentation, IntermediateStackBlock} = require('./intermediate');
+const {StackOpcode, InputOpcode, InputType} = require('./enums.js');
+
+class TypeState {
+    constructor () {
+        /** @type {Object.<string, InputType | 0>}*/
+        this.variables = {};
+        /** @type {InputType | 0} */
+        this.defaultType = 0;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    clear () {
+        let modified = false;
+        for (const varId in this.variables) {
+            if (this.variables[varId] !== InputType.ANY) {
+                modified = true;
+                break;
+            }
+        }
+        this.variables = {};
+        this.defaultType = InputType.ANY;
+        return modified;
+    }
+
+
+    /**
+     * @returns {TypeState}
+     */
+    clone () {
+        const clone = new TypeState();
+        for (const varId in this.variables) {
+            clone.variables[varId] = this.variables[varId];
+        }
+        clone.defaultType = this.defaultType;
+        return clone;
+    }
+
+    /**
+     * @param {TypeState} other
+     * @param {(varId: string) => InputType | 0} stateMutator
+     * @returns {boolean}
+     * @private
+     */
+    mutate (other, stateMutator) {
+        let modified = false;
+        for (const varId in other.variables) {
+            const newValue = stateMutator(varId);
+            if (newValue !== this.variables[varId]) {
+                this.variables[varId] = newValue;
+                modified = modified || true;
+            }
+        }
+
+        for (const varId in this.variables) {
+            if (!other.variables[varId]) {
+                const newValue = stateMutator(varId);
+                if (newValue !== this.variables[varId]) {
+                    this.variables[varId] = newValue;
+                    modified = modified || true;
+                }
+            }
+        }
+        return modified;
+    }
+
+    /**
+     * @param {TypeState} other
+     * @returns {boolean}
+     */
+    or (other) {
+        return this.mutate(other, varId => {
+            const thisType = this.variables[varId] ?? this.defaultType;
+            const otherType = other.variables[varId] ?? other.defaultType;
+            return thisType | otherType;
+        });
+    }
+
+    /**
+     * @param {TypeState} other
+     * @returns {boolean}
+     */
+    after (other) {
+        return this.mutate(other, varId => {
+            const otherType = other.variables[varId] ?? other.defaultType;
+            if (otherType !== 0) return otherType;
+            return this.variables[varId] ?? this.defaultType;
+        });
+    }
+
+    /**
+     * @param {*} variable A variable codegen object.
+     * @param {InputType} type The type to set this variable to
+     * @returns {boolean}
+     */
+    setVariableType (variable, type) {
+        if (this.getVariableType(variable) === type) return false;
+        this.variables[variable.id] = type;
+        return true;
+    }
+
+    /**
+     *
+     * @param {*} variable A variable codegen object.
+     * @returns {InputType}
+     */
+    getVariableType (variable) {
+        return this.variables[variable.id] ?? (this.defaultType === 0 ? InputType.ANY : this.defaultType);
+    }
+}
+
+class IROptimizer {
+
+    /**
+     * @param {IntermediateRepresentation} ir
+     */
+    constructor (ir) {
+        /** @type {IntermediateRepresentation} */
+        this.ir = ir;
+        /** @type {boolean} Used for testing */
+        this.ignoreYields = false;
+    }
+
+    /**
+     * @param {IntermediateInput} inputBlock
+     * @param {TypeState} state
+     * @returns {InputType}
+     */
+    getInputType (inputBlock, state) {
+        const inputs = inputBlock.inputs;
+
+        switch (inputBlock.opcode) {
+        case InputOpcode.VAR_GET:
+            return state.getVariableType(inputs.variable);
+
+        case InputOpcode.ADDON_CALL:
+
+
+        case InputOpcode.CAST_NUMBER: {
+            const innerType = inputs.target.type;
+            if (innerType & InputType.NUMBER) return innerType;
+            return InputType.NUMBER;
+        } case InputOpcode.CAST_NUMBER_OR_NAN: {
+            const innerType = inputs.target;
+            if (innerType & InputType.NUMBER_OR_NAN) return innerType;
+            return InputType.NUMBER_OR_NAN;
+        }
+
+        case InputOpcode.OP_ADD: {
+            const leftType = inputs.left.type;
+            const rightType = inputs.right.type;
+
+            let resultType = 0;
+
+            function canBeNaN () {
+                // Infinity + (-Infinity) = NaN
+                if ((leftType & InputType.NUMBER_POS_INF) && (rightType & InputType.NUMBER_NEG_INF)) return true;
+                // (-Infinity) + Infinity = NaN
+                if ((leftType & InputType.NUMBER_NEG_INF) && (rightType & InputType.NUMBER_POS_INF)) return true;
+            }
+            if (canBeNaN()) resultType |= InputType.NUMBER_NAN;
+
+            function canBeFractional () {
+                // For the plus operation to return a non-whole number one of it's
+                //  inputs has to be a non-whole number
+                if (leftType & InputType.NUMBER_FRACT) return true;
+                if (rightType & InputType.NUMBER_FRACT) return true;
+            }
+            const canBeFract = canBeFractional();
+
+            function canBePos () {
+                if (leftType & InputType.NUMBER_POS) return true; // POS + ANY ~= POS
+                if (rightType & InputType.NUMBER_POS) return true; // ANY + POS ~= POS
+            }
+            if (canBePos()) {
+                resultType |= InputType.NUMBER_POS_INT | InputType.NUMBER_POS_INF;
+                if (canBeFract) resultType |= InputType.NUMBER_POS_FRACT;
+            }
+
+            function canBeNeg () {
+                if (leftType & InputType.NUMBER_NEG) return true; // NEG + ANY ~= NEG
+                if (rightType & InputType.NUMBER_NEG) return true; // ANY + NEG ~= NEG
+            }
+            if (canBeNeg()) {
+                resultType |= InputType.NUMBER_NEG_INT | InputType.NUMBER_NEG_INF;
+                if (canBeFract) resultType |= InputType.NUMBER_NEG_FRACT;
+            }
+
+            function canBeZero () {
+                // POS_REAL + NEG_REAL ~= 0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+                // NEG_REAL + POS_REAL ~= 0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // 0 + 0 = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // 0 + -0 = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // -0 + 0 = 0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_ZERO)) return true;
+            }
+            if (canBeZero()) resultType |= InputType.NUMBER_ZERO;
+
+            function canBeNegZero () {
+                // -0 + -0 = -0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+            }
+            if (canBeNegZero()) resultType |= InputType.NUMBER_NEG_ZERO;
+
+            return resultType;
+        }
+
+        case InputOpcode.OP_SUBTRACT: {
+            const leftType = inputs.left.type;
+            const rightType = inputs.right.type;
+
+            let resultType = 0;
+
+            function canBeNaN () {
+                // Infinity - Infinity = NaN
+                if ((leftType & InputType.NUMBER_POS_INF) && (rightType & InputType.NUMBER_POS_INF)) return true;
+                // (-Infinity) - (-Infinity) = NaN
+                if ((leftType & InputType.NUMBER_NEG_INF) && (rightType & InputType.NUMBER_NEG_INF)) return true;
+            }
+            if (canBeNaN()) resultType |= InputType.NUMBER_NAN;
+
+            function canBeFractional () {
+                // For the subtract operation to return a non-whole number one of it's
+                //  inputs has to be a non-whole number
+                if (leftType & InputType.NUMBER_FRACT) return true;
+                if (rightType & InputType.NUMBER_FRACT) return true;
+            }
+            const canBeFract = canBeFractional();
+
+            function canBePos () {
+                if (leftType & InputType.NUMBER_POS) return true; // POS - ANY ~= POS
+                if (rightType & InputType.NUMBER_NEG) return true; // ANY - NEG ~= POS
+            }
+            if (canBePos()) {
+                resultType |= InputType.NUMBER_POS_INT | InputType.NUMBER_POS_INF;
+                if (canBeFract) resultType |= InputType.NUMBER_POS_FRACT;
+            }
+
+            function canBeNeg () {
+                if (leftType & InputType.NUMBER_NEG) return true; // NEG - ANY ~= NEG
+                if (rightType & InputType.NUMBER_POS) return true; // ANY - POS ~= NEG
+            }
+            if (canBeNeg()) {
+                resultType |= InputType.NUMBER_NEG_INT | InputType.NUMBER_NEG_INF;
+                if (canBeFract) resultType |= InputType.NUMBER_NEG_FRACT;
+            }
+
+            function canBeZero () {
+                // POS_REAL - POS_REAL ~= 0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // NEG_REAL - NEG_REAL ~= 0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+                // 0 - 0 = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // 0 - (-0) = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // (-0) - (-0) = 0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+            }
+            if (canBeZero()) resultType |= InputType.NUMBER_ZERO;
+
+            function canBeNegZero () {
+                // (-0) - 0 = -0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_ZERO)) return true;
+            }
+            if (canBeNegZero()) resultType |= InputType.NUMBER_NEG_ZERO;
+
+            return resultType;
+        }
+
+        case InputOpcode.OP_MULTIPLY: {
+            const leftType = inputs.left.type;
+            const rightType = inputs.right.type;
+
+            let resultType = 0;
+
+            function canBeNaN () {
+                // (-)Infinity * 0 = NaN
+                if ((leftType & InputType.NUMBER_INF) && (rightType & InputType.NUMBER_ANY_ZERO)) return true;
+                // 0 * (-)Infinity = NaN
+                if ((leftType & InputType.NUMBER_ANY_ZERO) && (rightType & InputType.NUMBER_INF)) return true;
+            }
+            if (canBeNaN()) resultType |= InputType.NUMBER_NAN;
+
+            function canBeFractional () {
+                // For the subtract operation to return a non-whole number one of it's
+                //  inputs has to be a non-whole number
+                if (leftType & InputType.NUMBER_FRACT) return true;
+                if (rightType & InputType.NUMBER_FRACT) return true;
+            }
+            const canBeFract = canBeFractional();
+
+            function canBePos () {
+                // POS * POS = POS
+                if ((leftType & InputType.NUMBER_POS) && (rightType & InputType.NUMBER_POS)) return true;
+                // NEG * NEG = POS
+                if ((leftType & InputType.NUMBER_NEG) && (rightType & InputType.NUMBER_NEG)) return true;
+            }
+            if (canBePos()) {
+                resultType |= InputType.NUMBER_POS_INT | InputType.NUMBER_POS_INF;
+                if (canBeFract) resultType |= InputType.NUMBER_POS_FRACT;
+            }
+
+            function canBeNeg () {
+                // POS * NEG = NEG
+                if ((leftType & InputType.NUMBER_POS) && (rightType & InputType.NUMBER_NEG)) return true;
+                // NEG * POS = NEG
+                if ((leftType & InputType.NUMBER_NEG) && (rightType & InputType.NUMBER_POS)) return true;
+            }
+            if (canBeNeg()) {
+                resultType |= InputType.NUMBER_NEG_INT | InputType.NUMBER_NEG_INF;
+                if (canBeFract) resultType |= InputType.NUMBER_NEG_FRACT;
+            }
+
+            function canBeZero () {
+                // 0 * 0 = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // -0 * -0 = 0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // 0 * POS_REAL = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // -0 * NEG_REAL = 0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+                // POS_REAL * 0 = 0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // NEG_REAL * -0 = 0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // Rounding errors like 1e-323 * 0.1 = 0
+                if ((leftType & InputType.NUMBER_FRACT) && (rightType & InputType.NUMBER_FRACT)) return true;
+            }
+            if (canBeZero()) resultType |= InputType.NUMBER_ZERO;
+
+            function canBeNegZero () {
+                // 0 * -0 = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // -0 * 0 = 0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // -0 * POS_REAL = -0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // 0 * NEG_REAL = -0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+                // POS_REAL * -0 = -0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // NEG_REAL * 0 = -0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // Rounding errors like -1e-323 / 10 = -0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // Rounding errors like 1e-323 / -10 = -0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+            }
+            if (canBeNegZero()) resultType |= InputType.NUMBER_NEG_ZERO;
+
+            return resultType;
+        }
+
+        case InputOpcode.OP_DIVIDE: {
+            const leftType = inputs.left.type;
+            const rightType = inputs.right.type;
+
+            let resultType = 0;
+
+            function canBeNaN () {
+                // REAL / 0 = NaN
+                if ((leftType & InputType.NUMBER_REAL) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // (-)Infinity / (-)Infinity = NaN
+                if ((leftType & InputType.NUMBER_INF) && (rightType & InputType.NUMBER_INF)) return true;
+                // (-)0 / NaN = NaN
+                if ((leftType & InputType.NUMBER_ANY_ZERO) && (rightType & InputType.NUMBER_NAN)) return true;
+            }
+            if (canBeNaN()) resultType |= InputType.NUMBER_NAN;
+
+            function canBePos () {
+                // POS / POS = POS
+                if ((leftType & InputType.NUMBER_POS) && (rightType & InputType.NUMBER_POS)) return true;
+                // NEG / NEG = POS
+                if ((leftType & InputType.NUMBER_NEG) && (rightType & InputType.NUMBER_NEG)) return true;
+            }
+            if (canBePos()) resultType |= InputType.NUMBER_POS;
+
+            function canBeNegInfinity () {
+                // -Infinity / 0 = -Infinity
+                if ((leftType & InputType.NUMBER_NEG_INF) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // Infinity / -0 = -Infinity
+                if ((leftType & InputType.NUMBER_POS_INF) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // NEG_REAL / NaN = -Infinity
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_NAN)) return true;
+                // NEG_REAL / NUMBER_OR_NAN ~= -Infinity
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_OR_NAN)) return true;
+            }
+            if (canBeNegInfinity()) resultType |= InputType.NUMBER_NEG_INF;
+
+            function canBeInfinity () {
+                // Infinity / 0 = Infinity
+                if ((leftType & InputType.NUMBER_POS_INF) && (rightType & InputType.NUMBER_ZERO)) return true;
+                // -Infinity / -0 = Infinity
+                if ((leftType & InputType.NUMBER_NEG_INF) && (rightType & InputType.NUMBER_NEG_ZERO)) return true;
+                // POS_REAL / NUMBER_OR_NAN ~= Infinity
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_OR_NAN)) return true;
+            }
+            if (canBeInfinity()) resultType |= InputType.NUMBER_POS_INF;
+
+            function canBeNeg () {
+                // POS / NEG = NEG
+                if ((leftType & InputType.NUMBER_POS) && (rightType & InputType.NUMBER_NEG)) return true;
+                // NEG / POS = NEG
+                if ((leftType & InputType.NUMBER_NEG) && (rightType & InputType.NUMBER_POS)) return true;
+            }
+            if (canBeNeg()) resultType |= InputType.NUMBER_NEG;
+
+            function canBeZero () {
+                // 0 / POS = 0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_POS)) return true;
+                // -0 / NEG = 0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_NEG)) return true;
+                // Rounding errors like 1e-323 / 10 = 0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // Rounding errors like -1e-323 / -10 = 0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+                // NUMBER_POS / Infinity = 0
+                if ((leftType & InputType.NUMBER_POS) && (rightType & InputType.NUMBER_POS_INF)) return true;
+                // NUMBER_NEG / -Infinity = 0
+                if ((leftType & InputType.NUMBER_NEG) && (rightType & InputType.NUMBER_NEG_INF)) return true;
+            }
+            if (canBeZero()) resultType |= InputType.NUMBER_ZERO;
+
+            function canBeNegZero () {
+                // -0 / POS = -0
+                if ((leftType & InputType.NUMBER_NEG_ZERO) && (rightType & InputType.NUMBER_POS)) return true;
+                // 0 / NEG = -0
+                if ((leftType & InputType.NUMBER_ZERO) && (rightType & InputType.NUMBER_NEG)) return true;
+                // Rounding errors like -1e-323 / 10 = -0
+                if ((leftType & InputType.NUMBER_NEG_REAL) && (rightType & InputType.NUMBER_POS_REAL)) return true;
+                // Rounding errors like 1e-323 / -10 = -0
+                if ((leftType & InputType.NUMBER_POS_REAL) && (rightType & InputType.NUMBER_NEG_REAL)) return true;
+                // NUMBER_POS / -Infinity = -0
+                if ((leftType & InputType.NUMBER_POS) && (rightType & InputType.NUMBER_NEG_INF)) return true;
+                // NUMBER_NEG / Infinity = -0
+                if ((leftType & InputType.NUMBER_NEG) && (rightType & InputType.NUMBER_POS_INF)) return true;
+            }
+            if (canBeNegZero()) resultType |= InputType.NUMBER_NEG_ZERO;
+
+            return resultType;
+        }
+        }
+        return inputBlock.type;
+    }
+
+    /**
+     * @param {IntermediateInput} inputBlock
+     * @param {TypeState} state
+     * @returns {boolean}
+     * @private
+     */
+    analyzeInputBlock (inputBlock, state) {
+        const inputs = inputBlock.inputs;
+
+        let modified = this.analyzeInputs(inputs, state);
+        const newType = this.getInputType(inputBlock, state);
+
+        modified = modified || newType !== inputBlock.type;
+        inputBlock.type = newType;
+
+        switch (inputBlock.opcode) {
+        case InputOpcode.ADDON_CALL:
+            modified = state.clear() || modified;
+            break;
+        case InputOpcode.PROCEDURE_CALL:
+            modified = this.analyzeInputs(inputs.inputs, state) || modified;
+            const script = this.ir.procedures[inputs.variant];
+
+            if (!script || !script.cachedAnalysisEndState) {
+                modified = state.clear() || modified;
+            } else {
+                modified = state.after(script.cachedAnalysisEndState) || modified;
+            }
+            break;
+        }
+
+        return modified;
+    }
+
+    /**
+     * @param {Object<any, any>} inputs
+     * @param {TypeState} state
+     * @returns {boolean} modified
+     */
+    analyzeInputs (inputs, state) {
+        let modified = false;
+        for (const inputName in inputs) {
+            const input = inputs[inputName];
+            if (input instanceof IntermediateInput) {
+                modified = this.analyzeInputBlock(input, state) || modified;
+            }
+        }
+        return modified;
+    }
+
+    /**
+     * @param {IntermediateStackBlock} stackBlock
+     * @param {TypeState} state
+     * @returns {boolean}
+     * @private
+     */
+    analyzeStackBlock (stackBlock, state) {
+        const inputs = stackBlock.inputs;
+        let modified = false;
+
+        if (stackBlock.ignoreState) {
+            state = state.clone();
+        }
+
+        modified = modified || this.analyzeInputs(inputs, state);
+
+        switch (stackBlock.opcode) {
+        case StackOpcode.VAR_SET:
+            modified = state.setVariableType(inputs.variable, inputs.value.type) || modified;
+            break;
+        case StackOpcode.CONTROL_WHILE:
+        case StackOpcode.CONTROL_FOR:
+        case StackOpcode.CONTROL_REPEAT:
+            modified = this.analyzeLoopedStack(inputs.do, state, stackBlock) || modified;
+            break;
+        case StackOpcode.CONTROL_IF_ELSE: {
+            const trueState = state.clone();
+            modified = this.analyzeStack(inputs.whenTrue, trueState) || modified;
+            modified = this.analyzeStack(inputs.whenFalse, state) || modified;
+            modified = state.or(trueState) || modified;
+            break;
+        }
+        case StackOpcode.PROCEDURE_CALL: {
+            modified = this.analyzeInputs(inputs.inputs, state) || modified;
+            const script = this.ir.procedures[inputs.variant];
+
+            if (!script || !script.cachedAnalysisEndState) {
+                modified = state.clear() || modified;
+            } else {
+                modified = state.after(script.cachedAnalysisEndState) || modified;
+            }
+            break;
+        }
+        case StackOpcode.COMPATIBILITY_LAYER: {
+            this.analyzeInputs(inputs.inputs, state);
+            for (const substack of inputs.substacks) {
+                const newState = state.clone();
+                modified = this.analyzeStack(substack, newState) || modified;
+                modified = state.or(newState) || modified;
+            }
+            break;
+        }
+        }
+
+        // if (stackBlock.ignoreState) return false;
+
+        return modified;
+    }
+
+    /**
+     * @param {IntermediateStack?} stack
+     * @param {TypeState} state
+     * @returns {boolean}
+     * @private
+     */
+    analyzeStack (stack, state) {
+        if (!stack) return false;
+        let modified = false;
+        for (const stackBlock of stack.blocks) {
+            let stateChanged = this.analyzeStackBlock(stackBlock, state);
+
+            if (!stackBlock.ignoreState) {
+                if (stackBlock.yields && !this.ignoreYields) stateChanged = state.clear() || stateChanged;
+
+                if (stateChanged) {
+                    if (stackBlock.exitState) stackBlock.exitState.or(state);
+                    else stackBlock.exitState = state.clone();
+                    modified = true;
+                }
+            }
+        }
+        return modified;
+    }
+
+    /**
+     * @param {IntermediateStack} stack
+     * @param {TypeState} state
+     * @param {IntermediateStackBlock} block
+     * @returns {boolean}
+     * @private
+     */
+    analyzeLoopedStack (stack, state, block) {
+        if (block.yields && !this.ignoreYields) {
+            const modified = state.clear();
+            block.entryState = state.clone();
+            block.exitState = state.clone();
+            return this.analyzeStack(stack, state) || modified;
+        }
+        let modified = false;
+        let keepLooping;
+        do {
+            const newState = state.clone();
+            this.analyzeStack(stack, newState);
+            modified = keepLooping = state.or(newState);
+        } while (keepLooping);
+        block.entryState = state.clone();
+        return modified;
+    }
+
+    /**
+     * @param {IntermediateInput} input
+     * @param {TypeState} state
+     * @returns {IntermediateInput}
+     * @private
+     */
+    optimizeInput (input, state) {
+        for (const inputKey in input.inputs) {
+            const inputInput = input.inputs[inputKey];
+            if (inputInput instanceof IntermediateInput) {
+                input.inputs[inputKey] = this.optimizeInput(inputInput, state);
+            }
+        }
+
+        switch (input.opcode) {
+        case InputOpcode.CAST_NUMBER: {
+            const targetType = input.inputs.target.type;
+            if ((targetType & InputType.NUMBER) === targetType) {
+                return input.inputs.target;
+            }
+            return input;
+        } case InputOpcode.CAST_NUMBER_OR_NAN: {
+            const targetType = input.inputs.target.type;
+            if ((targetType & InputType.NUMBER_OR_NAN) === targetType) {
+                return input.inputs.target;
+            }
+            return input;
+        }
+        }
+
+        return input;
+    }
+
+    /**
+     * @param {IntermediateStack?} stack
+     * @param {TypeState} state The state of the project before this stack is run.
+     * @private
+     */
+    optimizeStack (stack, state) {
+        if (!stack) return;
+        for (const stackBlock of stack.blocks) {
+            if (stackBlock.entryState) state = stackBlock.entryState;
+            for (const inputKey in stackBlock.inputs) {
+                const input = stackBlock.inputs[inputKey];
+                if (input instanceof IntermediateInput) {
+                    stackBlock.inputs[inputKey] = this.optimizeInput(input, state);
+                } else if (input instanceof IntermediateStack) {
+                    this.optimizeStack(input, state);
+                }
+            }
+            if (stackBlock.exitState) {
+                state = stackBlock.exitState;
+            }
+        }
+    }
+
+    /**
+     * @param {IntermediateScript} script
+     * @param {Set<string>} alreadyOptimized
+     * @private
+     */
+    optimizeScript (script, alreadyOptimized) {
+        if (script.isProcedure) {
+            if (alreadyOptimized.has(script.procedureCode)) {
+                return;
+            }
+            alreadyOptimized.add(script.procedureCode);
+        }
+
+        for (const procVariant of script.dependedProcedures) {
+            this.optimizeScript(this.ir.procedures[procVariant], alreadyOptimized);
+        }
+
+        script.cachedAnalysisEndState = new TypeState();
+        this.analyzeStack(script.stack, script.cachedAnalysisEndState);
+
+        this.optimizeStack(script.stack, new TypeState());
+    }
+
+    optimize () {
+        this.optimizeScript(this.ir.entry, new Set());
+    }
+}
+
+
+module.exports = {
+    IROptimizer,
+    TypeState
+};
@@ -1,3 +1,4 @@
+// @ts-check
 /**
 * @fileoverview Runtime for scripts generated by jsgen
 */
@@ -12,6 +13,7 @@ const globalState = {
    Cast: require('../util/cast'),
    log: require('../util/log'),
    blockUtility: require('./compat-block-utility'),
+    /** @type{import("../engine/thread")?} */
    thread: null
 };

@@ -119,9 +121,8 @@ const waitPromise = function*(promise) {
            returnValue = value;
            thread.status = 0; // STATUS_RUNNING
        }, error => {
-            globalState.log.warn('Promise rejected in compiled script:', error);
-            returnValue = '' + error;
            thread.status = 0; // STATUS_RUNNING
+            globalState.log.warn('Promise rejected in compiled script:', error);
        });

    yield;
@@ -163,7 +164,7 @@ const executeInCompatibilityLayer = function*(inputs, blockFunction, isWarp, use
        return returnValue;
    }

-    if (thread.status === 1 /* STATUS_PROMISE_WAIT */ || thread.status === 4 /* STATUS_DONE */) {
+    if (thread.status === 1 /* STATUS_PROMISE_WAIT */) {
        // Something external is forcing us to stop
        yield;
        // Make up a return value because whatever is forcing us to stop can't specify one
@@ -190,12 +191,14 @@ const executeInCompatibilityLayer = function*(inputs, blockFunction, isWarp, use
            return returnValue;
        }

-        if (thread.status === 1 /* STATUS_PROMISE_WAIT */ || thread.status === 4 /* STATUS_DONE */) {
+        if (thread.status === 1 /* STATUS_PROMISE_WAIT */) {
            yield;
            return finish('');
        }
    }

+    // todo: do we have to do anything extra if status is STATUS_DONE?
+
    return finish(returnValue);
 }`;

@@ -586,7 +589,7 @@ runtimeFunctions.yieldThenCallGenerator = `const yieldThenCallGenerator = functi

 /**
 * Step a compiled thread.
- * @param {Thread} thread The thread to step.
+ * @param {import("../engine/thread")} thread The thread to step.
 */
 const execute = thread => {
    globalState.thread = thread;
@@ -1,3 +1,5 @@
+// @ts-check
+
 class VariablePool {
    /**
     * @param {string} prefix The prefix at the start of the variable name.
@@ -17,7 +17,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 1)) {
+if ((b0.value === 1)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (1)",}, b2, false, false, "]4hbk*5ix]V00h|!x1oy", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 1 != " + ("" + b0.value)),}, b2, false, false, "H=x@7SpNJeX|!}8x5y4,", null);
@@ -75,7 +75,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 2)) {
+if ((b0.value === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (2)",}, b2, false, false, "0i[-T:vYTt=bi47@byUE", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 2 != " + ("" + b0.value)),}, b2, false, false, "Coc1aZ;L9M-RyEt`syps", null);
@@ -51,7 +51,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 1)) {
+if ((b0.value === 1)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (1)",}, b2, false, false, "RSQ{nVCc)6E)(`KlnFCF", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 1 != " + ("" + b0.value)),}, b2, false, false, "8k^j~`c^|YO@hkFd?~2d", null);
@@ -75,7 +75,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 2)) {
+if ((b0.value === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (2)",}, b2, false, false, "KP?op(=Vg2#;@]!,C#.~", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 2 != " + ("" + b0.value)),}, b2, false, false, "=]|}L~4uQXTNtwJKw_;R", null);
@@ -9,61 +9,61 @@ yield* executeInCompatibilityLayer({"MESSAGE":"plan 20",}, b0, false, false, "v"
 if ((("" + (0 * Infinity)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "6", null);
 }
-if (compareEqual((((0 * Infinity) || 0) * 1), 0)) {
+if (((((0 * Infinity) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "#", null);
 }
 if ((("" + ((Math.acos(1.01) * 180) / Math.PI)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "9", null);
 }
-if (compareEqual(((((Math.acos(1.01) * 180) / Math.PI) || 0) * 1), 0)) {
+if ((((((Math.acos(1.01) * 180) / Math.PI) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "(", null);
 }
 if ((("" + ((Math.asin(1.01) * 180) / Math.PI)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "*", null);
 }
-if (compareEqual(((((Math.asin(1.01) * 180) / Math.PI) || 0) * 1), 0)) {
+if ((((((Math.asin(1.01) * 180) / Math.PI) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, ",", null);
 }
 if ((("" + (0 / 0)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, ".", null);
 }
-if (compareEqual((((0 / 0) || 0) * 1), 0)) {
+if (((((0 / 0) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, ":", null);
 }
 if ((("" + Math.sqrt(-1)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "?", null);
 }
-if (compareEqual(((Math.sqrt(-1) || 0) * 1), 0)) {
+if ((((Math.sqrt(-1) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "@", null);
 }
 if ((("" + mod(0, 0)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "]", null);
 }
-if (compareEqual(((mod(0, 0) || 0) * 1), 0)) {
+if ((((mod(0, 0) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "_", null);
 }
 if ((("" + Math.log(-1)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "{", null);
 }
-if (compareEqual(((Math.log(-1) || 0) * 1), 0)) {
+if ((((Math.log(-1) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "}", null);
 }
 if ((("" + (Math.log(-1) / Math.LN10)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "aa", null);
 }
-if (compareEqual((((Math.log(-1) / Math.LN10) || 0) * 1), 0)) {
+if (((((Math.log(-1) / Math.LN10) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ac", null);
 }
-if (compareEqual((((Math.round(Math.sin((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1), 0)) {
+if (((((Math.round(Math.sin((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ae", null);
 }
-if (compareEqual((((Math.round(Math.cos((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1), 0)) {
+if (((((Math.round(Math.cos((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ag", null);
 }
-if (compareEqual(((tan(((1 / 0) || 0)) || 0) * 1), 0)) {
+if ((((tan(((1 / 0) || 0)) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ai", null);
 }
-if (compareEqual(((runtime.ext_scratch3_operators._random((-1 / 0), (1 / 0)) || 0) * 1), 0)) {
+if ((((runtime.ext_scratch3_operators._random((-1 / 0), (1 / 0)) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ak", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "7", null);
@@ -11,7 +11,7 @@ target.setSize(96);
 b1.value = 0;
 while (!(100 === Math.round(target.size))) {
 b1.value = ((+b1.value || 0) + 1);
-target.setSize(target.size + ((((100 - Math.round(target.size)) || 0) / 10) || 0));
+target.setSize(target.size + ((100 - Math.round(target.size)) / 10));
 yield;
 }
 if (((+b1.value || 0) === 20)) {
@@ -8,7 +8,7 @@ const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "c", null);
 b1.value = "#22388a";
-if ((("" + b1.value).toLowerCase() === "#22388a".toLowerCase())) {
+if ((b1.value.toLowerCase() === "#22388a".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "f", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "e", null);
@@ -123,13 +123,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 38: 0 should be = 🎉",}, b
 if (!(("" + ("0".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 39: 0 should be > 🎉",}, b0, false, false, "uq", null);
 }
-if (!(("" + compareLessThan(0, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 40: 0 should be < ",}, b0, false, false, "us", null);
 }
-if (!(("" + compareEqual(0, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0".toLowerCase() === "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 41: 0 should be = ",}, b0, false, false, "uu", null);
 }
-if (!(("" + compareGreaterThan(0, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("0".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 42: 0 should be > ",}, b0, false, false, "uw", null);
 }
 if (!(("" + (0 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -249,13 +249,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 80: 0.0 should be = 🎉",},
 if (!(("" + ("0.0".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 81: 0.0 should be > 🎉",}, b0, false, false, "vn", null);
 }
-if (!(("" + compareLessThan("0.0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0.0".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 82: 0.0 should be < ",}, b0, false, false, "vp", null);
 }
-if (!(("" + compareEqual("0.0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0.0".toLowerCase() === "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 83: 0.0 should be = ",}, b0, false, false, "vr", null);
 }
-if (!(("" + compareGreaterThan("0.0", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("0.0".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 84: 0.0 should be > ",}, b0, false, false, "vt", null);
 }
 if (!(("" + (1.23 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -324,7 +324,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 105: 1.23 should be > -1",},
 if (!(("" + ("1.23".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 106: 1.23 should be < true",}, b0, false, false, "v#", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 107: 1.23 should be = true",}, b0, false, false, "v(", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -333,7 +333,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 108: 1.23 should be > true",
 if (!(("" + ("1.23".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 109: 1.23 should be < false",}, b0, false, false, "v,", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 110: 1.23 should be = false",}, b0, false, false, "v.", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -342,7 +342,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 111: 1.23 should be > false"
 if (!(("" + ("1.23".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 112: 1.23 should be < NaN",}, b0, false, false, "v=", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 113: 1.23 should be = NaN",}, b0, false, false, "v@", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -360,7 +360,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 117: 1.23 should be > Infini
 if (!(("" + ("1.23".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 118: 1.23 should be < banana",}, b0, false, false, "wa", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 119: 1.23 should be = banana",}, b0, false, false, "wc", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -369,19 +369,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 120: 1.23 should be > banana
 if (!(("" + ("1.23".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 121: 1.23 should be < 🎉",}, b0, false, false, "wg", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 122: 1.23 should be = 🎉",}, b0, false, false, "wi", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 123: 1.23 should be > 🎉",}, b0, false, false, "wk", null);
 }
-if (!(("" + compareLessThan(1.23, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("1.23".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 124: 1.23 should be < ",}, b0, false, false, "wm", null);
 }
 if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 125: 1.23 should be = ",}, b0, false, false, "wo", null);
 }
-if (!(("" + compareGreaterThan(1.23, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("1.23".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 126: 1.23 should be > ",}, b0, false, false, "wq", null);
 }
 if (!(("" + (0.23 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -450,7 +450,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 147: .23 should be > -1",},
 if (!(("" + (".23".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 148: .23 should be < true",}, b0, false, false, "w8", null);
 }
-if (!(("" + (".23".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 149: .23 should be = true",}, b0, false, false, "w!", null);
 }
 if (!(("" + (".23".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -459,7 +459,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 150: .23 should be > true",}
 if (!(("" + (".23".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 151: .23 should be < false",}, b0, false, false, "w)", null);
 }
-if (!(("" + (".23".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 152: .23 should be = false",}, b0, false, false, "w+", null);
 }
 if (!(("" + (".23".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -468,7 +468,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 153: .23 should be > false",
 if (!(("" + (".23".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 154: .23 should be < NaN",}, b0, false, false, "w/", null);
 }
-if (!(("" + (".23".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 155: .23 should be = NaN",}, b0, false, false, "w;", null);
 }
 if (!(("" + (".23".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -486,7 +486,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 159: .23 should be > Infinit
 if (!(("" + (".23".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 160: .23 should be < banana",}, b0, false, false, "w|", null);
 }
-if (!(("" + (".23".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 161: .23 should be = banana",}, b0, false, false, "w~", null);
 }
 if (!(("" + (".23".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -495,19 +495,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 162: .23 should be > banana"
 if (!(("" + (".23".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 163: .23 should be < 🎉",}, b0, false, false, "xd", null);
 }
-if (!(("" + (".23".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 164: .23 should be = 🎉",}, b0, false, false, "xf", null);
 }
 if (!(("" + (".23".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 165: .23 should be > 🎉",}, b0, false, false, "xh", null);
 }
-if (!(("" + compareLessThan(".23", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (".23".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 166: .23 should be < ",}, b0, false, false, "xj", null);
 }
-if (!(("" + compareEqual(".23", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 167: .23 should be = ",}, b0, false, false, "xl", null);
 }
-if (!(("" + compareGreaterThan(".23", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + (".23".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 168: .23 should be > ",}, b0, false, false, "xn", null);
 }
 if (!(("" + (0.123 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -576,7 +576,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 189: 0.123 should be > -1",}
 if (!(("" + ("0.123".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 190: 0.123 should be < true",}, b0, false, false, "x5", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 191: 0.123 should be = true",}, b0, false, false, "x7", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -585,7 +585,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 192: 0.123 should be > true"
 if (!(("" + ("0.123".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 193: 0.123 should be < false",}, b0, false, false, "x#", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 194: 0.123 should be = false",}, b0, false, false, "x(", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -594,7 +594,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 195: 0.123 should be > false
 if (!(("" + ("0.123".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 196: 0.123 should be < NaN",}, b0, false, false, "x,", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 197: 0.123 should be = NaN",}, b0, false, false, "x.", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -612,7 +612,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 201: 0.123 should be > Infin
 if (!(("" + ("0.123".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 202: 0.123 should be < banana",}, b0, false, false, "x_", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 203: 0.123 should be = banana",}, b0, false, false, "x{", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -621,19 +621,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 204: 0.123 should be > banan
 if (!(("" + ("0.123".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 205: 0.123 should be < 🎉",}, b0, false, false, "ya", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 206: 0.123 should be = 🎉",}, b0, false, false, "yc", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 207: 0.123 should be > 🎉",}, b0, false, false, "ye", null);
 }
-if (!(("" + compareLessThan(0.123, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0.123".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 208: 0.123 should be < ",}, b0, false, false, "yg", null);
 }
 if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 209: 0.123 should be = ",}, b0, false, false, "yi", null);
 }
-if (!(("" + compareGreaterThan(0.123, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("0.123".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 210: 0.123 should be > ",}, b0, false, false, "yk", null);
 }
 if (!(("" + (-0 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -753,13 +753,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 248: -0 should be = 🎉",},
 if (!(("" + ("-0".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 249: -0 should be > 🎉",}, b0, false, false, "zb", null);
 }
-if (!(("" + compareLessThan("-0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("-0".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 250: -0 should be < ",}, b0, false, false, "zd", null);
 }
-if (!(("" + compareEqual("-0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("-0".toLowerCase() === "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 251: -0 should be = ",}, b0, false, false, "zf", null);
 }
-if (!(("" + compareGreaterThan("-0", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("-0".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 252: -0 should be > ",}, b0, false, false, "zh", null);
 }
 if (!(("" + (-1 < 0)).toLowerCase() === "true".toLowerCase())) {
@@ -828,7 +828,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 273: -1 should be > -1",}, b
 if (!(("" + ("-1".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 274: -1 should be < true",}, b0, false, false, "zZ", null);
 }
-if (!(("" + ("-1".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 275: -1 should be = true",}, b0, false, false, "z1", null);
 }
 if (!(("" + ("-1".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -837,7 +837,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 276: -1 should be > true",},
 if (!(("" + ("-1".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 277: -1 should be < false",}, b0, false, false, "z5", null);
 }
-if (!(("" + ("-1".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 278: -1 should be = false",}, b0, false, false, "z7", null);
 }
 if (!(("" + ("-1".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -846,7 +846,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 279: -1 should be > false",}
 if (!(("" + ("-1".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 280: -1 should be < NaN",}, b0, false, false, "z#", null);
 }
-if (!(("" + ("-1".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 281: -1 should be = NaN",}, b0, false, false, "z(", null);
 }
 if (!(("" + ("-1".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -864,7 +864,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 285: -1 should be > Infinity
 if (!(("" + ("-1".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 286: -1 should be < banana",}, b0, false, false, "z=", null);
 }
-if (!(("" + ("-1".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 287: -1 should be = banana",}, b0, false, false, "z@", null);
 }
 if (!(("" + ("-1".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -873,19 +873,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 288: -1 should be > banana",
 if (!(("" + ("-1".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 289: -1 should be < 🎉",}, b0, false, false, "z_", null);
 }
-if (!(("" + ("-1".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 290: -1 should be = 🎉",}, b0, false, false, "z{", null);
 }
 if (!(("" + ("-1".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 291: -1 should be > 🎉",}, b0, false, false, "z}", null);
 }
-if (!(("" + compareLessThan(-1, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("-1".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 292: -1 should be < ",}, b0, false, false, "Aa", null);
 }
 if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 293: -1 should be = ",}, b0, false, false, "Ac", null);
 }
-if (!(("" + compareGreaterThan(-1, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("-1".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 294: -1 should be > ",}, b0, false, false, "Ae", null);
 }
 if (!(("" + ("true".toLowerCase() < "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -909,7 +909,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 300: true should be > 0.0",}
 if (!(("" + ("true".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 301: true should be < 1.23",}, b0, false, false, "As", null);
 }
-if (!(("" + ("true".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 302: true should be = 1.23",}, b0, false, false, "Au", null);
 }
 if (!(("" + ("true".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -918,7 +918,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 303: true should be > 1.23",
 if (!(("" + ("true".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 304: true should be < .23",}, b0, false, false, "Ay", null);
 }
-if (!(("" + ("true".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 305: true should be = .23",}, b0, false, false, "AA", null);
 }
 if (!(("" + ("true".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -927,7 +927,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 306: true should be > .23",}
 if (!(("" + ("true".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 307: true should be < 0.123",}, b0, false, false, "AE", null);
 }
-if (!(("" + ("true".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 308: true should be = 0.123",}, b0, false, false, "AG", null);
 }
 if (!(("" + ("true".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -945,7 +945,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 312: true should be > -0",},
 if (!(("" + ("true".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 313: true should be < -1",}, b0, false, false, "AQ", null);
 }
-if (!(("" + ("true".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 314: true should be = -1",}, b0, false, false, "AS", null);
 }
 if (!(("" + ("true".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -981,7 +981,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 324: true should be > NaN",}
 if (!(("" + ("true".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 325: true should be < Infinity",}, b0, false, false, "A)", null);
 }
-if (!(("" + ("true".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 326: true should be = Infinity",}, b0, false, false, "A+", null);
 }
 if (!(("" + ("true".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1035,7 +1035,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 342: false should be > 0.0",
 if (!(("" + ("false".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 343: false should be < 1.23",}, b0, false, false, "Bp", null);
 }
-if (!(("" + ("false".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 344: false should be = 1.23",}, b0, false, false, "Br", null);
 }
 if (!(("" + ("false".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1044,7 +1044,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 345: false should be > 1.23"
 if (!(("" + ("false".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 346: false should be < .23",}, b0, false, false, "Bv", null);
 }
-if (!(("" + ("false".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 347: false should be = .23",}, b0, false, false, "Bx", null);
 }
 if (!(("" + ("false".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1053,7 +1053,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 348: false should be > .23",
 if (!(("" + ("false".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 349: false should be < 0.123",}, b0, false, false, "BB", null);
 }
-if (!(("" + ("false".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 350: false should be = 0.123",}, b0, false, false, "BD", null);
 }
 if (!(("" + ("false".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1071,7 +1071,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 354: false should be > -0",}
 if (!(("" + ("false".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 355: false should be < -1",}, b0, false, false, "BN", null);
 }
-if (!(("" + ("false".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 356: false should be = -1",}, b0, false, false, "BP", null);
 }
 if (!(("" + ("false".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1107,7 +1107,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 366: false should be > NaN",
 if (!(("" + ("false".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 367: false should be < Infinity",}, b0, false, false, "B#", null);
 }
-if (!(("" + ("false".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 368: false should be = Infinity",}, b0, false, false, "B(", null);
 }
 if (!(("" + ("false".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1161,7 +1161,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 384: NaN should be > 0.0",},
 if (!(("" + ("NaN".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 385: NaN should be < 1.23",}, b0, false, false, "Cm", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 386: NaN should be = 1.23",}, b0, false, false, "Co", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1170,7 +1170,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 387: NaN should be > 1.23",}
 if (!(("" + ("NaN".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 388: NaN should be < .23",}, b0, false, false, "Cs", null);
 }
-if (!(("" + ("NaN".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 389: NaN should be = .23",}, b0, false, false, "Cu", null);
 }
 if (!(("" + ("NaN".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1179,7 +1179,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 390: NaN should be > .23",},
 if (!(("" + ("NaN".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 391: NaN should be < 0.123",}, b0, false, false, "Cy", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 392: NaN should be = 0.123",}, b0, false, false, "CA", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1197,7 +1197,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 396: NaN should be > -0",},
 if (!(("" + ("NaN".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 397: NaN should be < -1",}, b0, false, false, "CK", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 398: NaN should be = -1",}, b0, false, false, "CM", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1233,7 +1233,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 408: NaN should be > NaN",},
 if (!(("" + ("NaN".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 409: NaN should be < Infinity",}, b0, false, false, "C8", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 410: NaN should be = Infinity",}, b0, false, false, "C!", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1332,7 +1332,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 441: Infinity should be > -1
 if (!(("" + ("Infinity".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 442: Infinity should be < true",}, b0, false, false, "DN", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 443: Infinity should be = true",}, b0, false, false, "DP", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1341,7 +1341,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 444: Infinity should be > tr
 if (!(("" + ("Infinity".toLowerCase() < "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 445: Infinity should be < false",}, b0, false, false, "DT", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 446: Infinity should be = false",}, b0, false, false, "DV", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1350,7 +1350,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 447: Infinity should be > fa
 if (!(("" + ("Infinity".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 448: Infinity should be < NaN",}, b0, false, false, "DZ", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 449: Infinity should be = NaN",}, b0, false, false, "D1", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1368,7 +1368,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 453: Infinity should be > In
 if (!(("" + ("Infinity".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 454: Infinity should be < banana",}, b0, false, false, "D#", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 455: Infinity should be = banana",}, b0, false, false, "D(", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1377,19 +1377,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 456: Infinity should be > ba
 if (!(("" + ("Infinity".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 457: Infinity should be < 🎉",}, b0, false, false, "D,", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 458: Infinity should be = 🎉",}, b0, false, false, "D.", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 459: Infinity should be > 🎉",}, b0, false, false, "D:", null);
 }
-if (!(("" + compareLessThan(Infinity, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("Infinity".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 460: Infinity should be < ",}, b0, false, false, "D=", null);
 }
 if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 461: Infinity should be = ",}, b0, false, false, "D@", null);
 }
-if (!(("" + compareGreaterThan(Infinity, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("Infinity".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 462: Infinity should be > ",}, b0, false, false, "D]", null);
 }
 if (!(("" + ("banana".toLowerCase() < "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1413,7 +1413,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 468: banana should be > 0.0"
 if (!(("" + ("banana".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 469: banana should be < 1.23",}, b0, false, false, "Eg", null);
 }
-if (!(("" + ("banana".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 470: banana should be = 1.23",}, b0, false, false, "Ei", null);
 }
 if (!(("" + ("banana".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1422,7 +1422,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 471: banana should be > 1.23
 if (!(("" + ("banana".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 472: banana should be < .23",}, b0, false, false, "Em", null);
 }
-if (!(("" + ("banana".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 473: banana should be = .23",}, b0, false, false, "Eo", null);
 }
 if (!(("" + ("banana".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1431,7 +1431,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 474: banana should be > .23"
 if (!(("" + ("banana".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 475: banana should be < 0.123",}, b0, false, false, "Es", null);
 }
-if (!(("" + ("banana".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 476: banana should be = 0.123",}, b0, false, false, "Eu", null);
 }
 if (!(("" + ("banana".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1449,7 +1449,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 480: banana should be > -0",
 if (!(("" + ("banana".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 481: banana should be < -1",}, b0, false, false, "EE", null);
 }
-if (!(("" + ("banana".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 482: banana should be = -1",}, b0, false, false, "EG", null);
 }
 if (!(("" + ("banana".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1485,7 +1485,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 492: banana should be > NaN"
 if (!(("" + ("banana".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 493: banana should be < Infinity",}, b0, false, false, "E2", null);
 }
-if (!(("" + ("banana".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 494: banana should be = Infinity",}, b0, false, false, "E4", null);
 }
 if (!(("" + ("banana".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1539,7 +1539,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 510: 🎉 should be > 0.0",}
 if (!(("" + ("🎉".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 511: 🎉 should be < 1.23",}, b0, false, false, "Fd", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 512: 🎉 should be = 1.23",}, b0, false, false, "Ff", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1548,7 +1548,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 513: 🎉 should be > 1.23",
 if (!(("" + ("🎉".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 514: 🎉 should be < .23",}, b0, false, false, "Fj", null);
 }
-if (!(("" + ("🎉".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 515: 🎉 should be = .23",}, b0, false, false, "Fl", null);
 }
 if (!(("" + ("🎉".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1557,7 +1557,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 516: 🎉 should be > .23",}
 if (!(("" + ("🎉".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 517: 🎉 should be < 0.123",}, b0, false, false, "Fp", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 518: 🎉 should be = 0.123",}, b0, false, false, "Fr", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1575,7 +1575,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 522: 🎉 should be > -0",},
 if (!(("" + ("🎉".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 523: 🎉 should be < -1",}, b0, false, false, "FB", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 524: 🎉 should be = -1",}, b0, false, false, "FD", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1611,7 +1611,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 534: 🎉 should be > NaN",}
 if (!(("" + ("🎉".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 535: 🎉 should be < Infinity",}, b0, false, false, "FZ", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 536: 🎉 should be = Infinity",}, b0, false, false, "F1", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1644,67 +1644,67 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 545: 🎉 should be = ",}, b
 if (!(("" + ("🎉".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 546: 🎉 should be > ",}, b0, false, false, "F:", null);
 }
-if (!(("" + compareLessThan("", 0)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "0".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 547:  should be < 0",}, b0, false, false, "F=", null);
 }
-if (!(("" + compareEqual("", 0)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 548:  should be = 0",}, b0, false, false, "F@", null);
 }
-if (!(("" + compareGreaterThan("", 0)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 549:  should be > 0",}, b0, false, false, "F]", null);
 }
-if (!(("" + compareLessThan("", "0.0")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "0.0".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 550:  should be < 0.0",}, b0, false, false, "F_", null);
 }
-if (!(("" + compareEqual("", "0.0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "0.0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 551:  should be = 0.0",}, b0, false, false, "F{", null);
 }
-if (!(("" + compareGreaterThan("", "0.0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "0.0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 552:  should be > 0.0",}, b0, false, false, "F}", null);
 }
-if (!(("" + compareLessThan("", 1.23)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 553:  should be < 1.23",}, b0, false, false, "Ga", null);
 }
 if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 554:  should be = 1.23",}, b0, false, false, "Gc", null);
 }
-if (!(("" + compareGreaterThan("", 1.23)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 555:  should be > 1.23",}, b0, false, false, "Ge", null);
 }
-if (!(("" + compareLessThan("", ".23")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 556:  should be < .23",}, b0, false, false, "Gg", null);
 }
-if (!(("" + compareEqual("", ".23")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 557:  should be = .23",}, b0, false, false, "Gi", null);
 }
-if (!(("" + compareGreaterThan("", ".23")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 558:  should be > .23",}, b0, false, false, "Gk", null);
 }
-if (!(("" + compareLessThan("", 0.123)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 559:  should be < 0.123",}, b0, false, false, "Gm", null);
 }
 if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 560:  should be = 0.123",}, b0, false, false, "Go", null);
 }
-if (!(("" + compareGreaterThan("", 0.123)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 561:  should be > 0.123",}, b0, false, false, "Gq", null);
 }
-if (!(("" + compareLessThan("", "-0")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "-0".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 562:  should be < -0",}, b0, false, false, "Gs", null);
 }
-if (!(("" + compareEqual("", "-0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "-0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 563:  should be = -0",}, b0, false, false, "Gu", null);
 }
-if (!(("" + compareGreaterThan("", "-0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "-0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 564:  should be > -0",}, b0, false, false, "Gw", null);
 }
-if (!(("" + compareLessThan("", -1)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 565:  should be < -1",}, b0, false, false, "Gy", null);
 }
 if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 566:  should be = -1",}, b0, false, false, "GA", null);
 }
-if (!(("" + compareGreaterThan("", -1)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 567:  should be > -1",}, b0, false, false, "GC", null);
 }
 if (!(("" + ("".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1734,13 +1734,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 575:  should be = NaN",}, b0
 if (!(("" + ("".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 576:  should be > NaN",}, b0, false, false, "GU", null);
 }
-if (!(("" + compareLessThan("", Infinity)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 577:  should be < Infinity",}, b0, false, false, "GW", null);
 }
 if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 578:  should be = Infinity",}, b0, false, false, "GY", null);
 }
-if (!(("" + compareGreaterThan("", Infinity)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 579:  should be > Infinity",}, b0, false, false, "G0", null);
 }
 if (!(("" + ("".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1761,13 +1761,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 584:  should be = 🎉",}, b
 if (!(("" + ("".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 585:  should be > 🎉",}, b0, false, false, "G%", null);
 }
-if (!(("" + compareLessThan("", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 586:  should be < ",}, b0, false, false, "G)", null);
 }
-if (!(("" + compareEqual("", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 587:  should be = ",}, b0, false, false, "G+", null);
 }
-if (!(("" + compareGreaterThan("", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 588:  should be > ",}, b0, false, false, "G.", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "G-", null);
@@ -11,7 +11,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "aZ", n
 retire(); return;
 }; })

-// Sprite1 Wrun test
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["mfV;yS}9e:%h5UZ)QyiY"];
 const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
@@ -29,15 +29,15 @@ b3.value = 0;
 for (var a1 = b2.value.length; a1 >= 0.5; a1--) {
 b3.value = ((+b3.value || 0) + 1);
 b0.value = ((+b0.value || 0) + 1);
-if (!compareEqual(compareGreaterThan(listGet(b2.value, b1.value), (b2.value[((b3.value || 0) | 0) - 1] ?? "")), (b4.value[((b0.value || 0) | 0) - 1] ?? ""))) {
-yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be > " + ("" + listGet(b2.value, b3.value))))),}, b5, true, false, "]", null);
+if (!compareEqual(compareGreaterThan(listGet(b2.value, b1.value), (b2.value[(b3.value | 0) - 1] ?? "")), (b4.value[(b0.value | 0) - 1] ?? ""))) {
+yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be > " + ("" + (b2.value[(b3.value | 0) - 1] ?? ""))))),}, b5, true, false, "]", null);
 }
 b0.value = ((+b0.value || 0) + 1);
-if (!compareEqual(compareEqual(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[((b0.value || 0) | 0) - 1] ?? ""))) {
+if (!compareEqual(compareEqual(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[(b0.value | 0) - 1] ?? ""))) {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be = " + ("" + listGet(b2.value, b3.value))))),}, b5, true, false, "|", null);
 }
 b0.value = ((+b0.value || 0) + 1);
-if (!compareEqual(compareLessThan(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[((b0.value || 0) | 0) - 1] ?? ""))) {
+if (!compareEqual(compareLessThan(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[(b0.value | 0) - 1] ?? ""))) {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be < " + ("" + listGet(b2.value, b3.value))))),}, b5, true, true, "ab", null);
 if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 }
@@ -46,7 +46,7 @@ if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 return "";
 }; })

-// Sprite1 Wsetup values
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["n^wm8jw#b24sggt.S^tD"];
 return function funXYZ_setup_values () {
@@ -105,7 +105,7 @@ b0.value.push((-1 / 0));
 b0._monitorUpToDate = false;
 b0.value.push((0 / 0));
 b0._monitorUpToDate = false;
-b0.value.push(NaN);
+b0.value.push("NaN");
 b0._monitorUpToDate = false;
 b0.value.push("nan");
 b0._monitorUpToDate = false;
@@ -19,7 +19,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "l", nu
 retire(); return;
 }; })

-// Sprite1 Zblock name
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_block_name () {
 return 40;
@@ -12,10 +12,10 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "k", n
 if (compareLessThan(("something".toLowerCase() === "else".toLowerCase()), ("1" + ""))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "m", null);
 }
-if (compareGreaterThan(("something".toLowerCase() === "something".toLowerCase()), (0 + 0))) {
+if (((+("something".toLowerCase() === "something".toLowerCase())) > (0 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "n", null);
 }
-if (compareLessThan(("something".toLowerCase() === "else".toLowerCase()), (1 + 0))) {
+if (((+("something".toLowerCase() === "else".toLowerCase())) < (1 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "o", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "l", null);
@@ -9,13 +9,13 @@ const b2 = target.variables["zShM`!CD?d_|Z,]5X}N6"];
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 2",}, b0, false, false, "d", null);
 b1.value = 2;
-if (((+b1.value || 0) === 2)) {
+if ((b1.value === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass variable",}, b0, false, false, "k", null);
 }
 b2.value = [];
 b2.value.push(3);
 b2._monitorUpToDate = false;
-if (((+(b2.value[(1 | 0) - 1] ?? "") || 0) === 3)) {
+if (((+(b2.value[1 - 1] ?? "") || 0) === 3)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass list",}, b0, false, false, "m", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "l", null);
@@ -21,7 +21,7 @@ retire(); return;
 retire(); return;
 }; })

-// Sprite1 Wno refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("music_restForBeats");
 const b1 = runtime.getOpcodeFunction("music_playDrumForBeats");
@@ -41,14 +41,14 @@ runtime.ext_scratch3_motion._moveSteps(0, target);
 return "";
 }; })

-// Sprite1 Wruns below with no refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function* genXYZ_runs_below_with_no_r () {
 yield* thread.procedures["Whas refresh"]();
 return "";
 }; })

-// Sprite1 Whas refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("music_restForBeats");
 const b1 = runtime.getOpcodeFunction("music_playDrumForBeats");
@@ -11,14 +11,14 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "g", nu
 retire(); return;
 }; })

-// Sprite1 Zfoo %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_foo_ (p0) {
 return "";
 return "";
 }; })

-// Sprite1 Zno op
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_no_op () {
 return "";
@@ -30,7 +30,7 @@ listDelete(b1, "any");
 if ((b1.value.length === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "C", null);
 }
-if (compareEqual(listGet(b1.value, "*"), "")) {
+if ((("" + listGet(b1.value, "*")).toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "F", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "E", null);
@@ -6,7 +6,7 @@
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "@|B*yJ0zKh!acN`7L-N5", null);
-if ((((1 / -0) || 0) === -Infinity)) {
+if (((1 / -0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "=enYDFG11Nj/0BL:y56w", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, ",Cpv8W0RH0RgNky[1xb:", null);
@@ -11,7 +11,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "Q^(MKg
 retire(); return;
 }; })

-// Player ZSet Costume
+// Player script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_Set_Costume () {
@@ -12,7 +12,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "$R-1lb
 retire(); return;
 }; })

-// Sprite1 Znumber or text %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_number_or_text__ (p0,p1) {
@@ -22,7 +22,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "HH`yR
 return "";
 }; })

-// Sprite1 Zboolean %b %b
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_boolean__ (p0,p1) {
@@ -9,14 +9,14 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "qf{MD}-f+l?U+)KA#Vnm", null);
 b1.value = "";
 thread.procedures["Zdo something"]();
-if (!compareEqual(b1.value, "")) {
+if (!(b1.value.toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "Sgf_#7|GOpx!R]?Q3]$s", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, ",vD-ZG7f{]FoJ`,))JWh", null);
 retire(); return;
 }; })

-// Sprite1 Zdo something
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
 return function funXYZ_do_something () {
@@ -39,14 +39,14 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "P", nu
 retire(); return;
 }; })

-// Sprite1 Zinvalid params - reporter
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_invalid_params___rep () {
 return 0;
 return "";
 }; })

-// Sprite1 Zinvalid params - boolean
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_invalid_params___boo () {
 return 0;
@@ -9,7 +9,7 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "d", null);
 b1.value = "discard me";
 b1.value = "";
-if (compareEqual(b1.value, "")) {
+if ((("" + b1.value).toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non existent procedure returned empty string",}, b0, false, false, "h", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "g", null);
@@ -10,17 +10,17 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 18",}, b0, false, false, "G", null);
 b1.value = 0;
 b2.value = (yield* thread.procedures["Znon warp recursion should yield %s"](8));
-if (((+b1.value || 0) === 4)) {
+if ((b1.value === 4)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non warp recursion yields",}, b0, false, false, "ao", null);
 }
 b1.value = 0;
 b2.value = thread.procedures["Wwarp recursion should not yield %s"](8);
-if (((+b1.value || 0) === 0)) {
+if ((b1.value === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass warp recursion does not yield",}, b0, false, false, "ar", null);
 }
 b1.value = 0;
 b2.value = (yield* thread.procedures["Zfib %s"](7));
-if (((+b1.value || 0) === 20)) {
+if ((b1.value === 20)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non warp fib yielded",}, b0, false, false, "au", null);
 }
 yield* thread.procedures["Zrecursing yields between each %s"]("initial");
@@ -30,7 +30,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "av", n
 retire(); return;
 }; })

-// Sprite1 Znon warp recursion should yield %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function* genXYZ_non_warp_recursion_s (p0) {
 if (compareGreaterThan(p0, 0)) {
@@ -39,7 +39,7 @@ return (yield* yieldThenCallGenerator(thread.procedures["Znon warp recursion sho
 return "";
 }; })

-// Sprite1 Wwarp recursion should not yield %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_warp_recursion_shoul (p0) {
 if (compareGreaterThan(p0, 0)) {
@@ -48,7 +48,7 @@ return thread.procedures["Wwarp recursion should not yield %s"](((+p0 || 0) - 1)
 return "";
 }; })

-// Sprite1 Zfib %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function* genXYZ_fib_ (p0) {
 if (compareLessThan(p0, 2)) {
@@ -59,7 +59,7 @@ return ((+(yield* yieldThenCallGenerator(thread.procedures["Zfib %s"], ((+p0 ||
 return "";
 }; })

-// Sprite1 Zrecursing yields between each %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
@@ -68,7 +68,7 @@ return function* genXYZ_recursing_yields_bet (p0) {
 if ((("" + p0).toLowerCase() === "initial".toLowerCase())) {
 b0.value = 0;
 b1.value = ((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 1)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 1)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 2)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 2)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 3)) || 0) + (+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 3)) || 0)) || 0)) || 0)) || 0)) || 0));
-if (((+b0.value || 0) === 3)) {
+if ((b0.value === 3)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recursing between calls yields final",}, b2, false, false, "aK", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail recursing between calls yields final",}, b2, false, false, "aL", null);
@@ -83,7 +83,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":("fail recursing between calls yie
 return "";
 }; })

-// Sprite1 Zrecursing arguments eval order %s %s %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["4HH82mPlVMOONdl(Ot*7"];
 const b1 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
@@ -94,25 +94,25 @@ if ((("" + p0).toLowerCase() === "initial".toLowerCase())) {
 b0.value = [];
 b1.value = 0;
 b2.value = (yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 1",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 2",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 3",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 4","","","")),(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 5","","","")),(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 6","","","")))),"","")),"",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 7","","",""))));
-if ((("" + (b0.value[(1 | 0) - 1] ?? "")).toLowerCase() === "1/child 4".toLowerCase())) {
+if ((("" + (b0.value[1 - 1] ?? "")).toLowerCase() === "1/child 4".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 1",}, b3, false, false, "aZ", null);
 }
-if ((("" + (b0.value[(2 | 0) - 1] ?? "")).toLowerCase() === "1/child 5".toLowerCase())) {
+if ((("" + (b0.value[2 - 1] ?? "")).toLowerCase() === "1/child 5".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 2",}, b3, false, false, "a#", null);
 }
-if ((("" + (b0.value[(3 | 0) - 1] ?? "")).toLowerCase() === "2/child 6".toLowerCase())) {
+if ((("" + (b0.value[3 - 1] ?? "")).toLowerCase() === "2/child 6".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 3",}, b3, false, false, "a(", null);
 }
-if ((("" + (b0.value[(4 | 0) - 1] ?? "")).toLowerCase() === "2/child 3".toLowerCase())) {
+if ((("" + (b0.value[4 - 1] ?? "")).toLowerCase() === "2/child 3".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 4",}, b3, false, false, "a*", null);
 }
-if ((("" + (b0.value[(5 | 0) - 1] ?? "")).toLowerCase() === "3/child 2".toLowerCase())) {
+if ((("" + (b0.value[5 - 1] ?? "")).toLowerCase() === "3/child 2".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 5",}, b3, false, false, "a,", null);
 }
-if ((("" + (b0.value[(6 | 0) - 1] ?? "")).toLowerCase() === "3/child 7".toLowerCase())) {
+if ((("" + (b0.value[6 - 1] ?? "")).toLowerCase() === "3/child 7".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 6",}, b3, false, false, "a.", null);
 }
-if ((("" + (b0.value[(7 | 0) - 1] ?? "")).toLowerCase() === "4/child 1".toLowerCase())) {
+if ((("" + (b0.value[7 - 1] ?? "")).toLowerCase() === "4/child 1".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 7",}, b3, false, false, "a:", null);
 }
 if ((b0.value.length === 7)) {
@@ -20,21 +20,21 @@ if (((+thread.procedures["Wfactorial %s"](12) || 0) === 479001600)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass factorial 12",}, b0, false, false, "]", null);
 }
 b1.value = (yield* thread.procedures["Zno shadowing 1 %s %s"]("f","g"));
-if (compareEqual(b1.value, "")) {
+if ((("" + b1.value).toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass default return value",}, b0, false, false, "|", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "`", null);
 retire(); return;
 }; })

-// Sprite1 Zsimplest
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_simplest () {
 return "It works!";
 return "";
 }; })

-// Sprite1 Znesting 1
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_nesting_1 () {
 thread.procedures["Znesting 2"]();
@@ -42,14 +42,14 @@ return (("" + thread.procedures["Znesting 3 %s %s"](6,7)) + ("" + thread.procedu
 return "";
 }; })

-// Sprite1 Wwarp fib %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_warp_fib_ (p0) {
 return thread.procedures["Wfib %s"](p0);
 return "";
 }; })

-// Sprite1 Wfactorial %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_factorial_ (p0) {
 if (compareGreaterThan(p0, 1)) {
@@ -59,7 +59,7 @@ return 1;
 return "";
 }; })

-// Sprite1 Zno shadowing 1 %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
@@ -78,21 +78,21 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass shadow check 3",}, b0, false
 return "";
 }; })

-// Sprite1 Znesting 2
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_nesting_2 () {
 return "discard nesting 2";
 return "";
 }; })

-// Sprite1 Znesting 3 %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_nesting_3__ (p0,p1) {
 return ((+p0 || 0) * (+p1 || 0));
 return "";
 }; })

-// Sprite1 Wfib %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_fib_ (p0) {
 if (compareLessThan(p0, 2)) {
@@ -103,7 +103,7 @@ return ((+thread.procedures["Wfib %s"](((+p0 || 0) - 1)) || 0) + (+thread.proced
 return "";
 }; })

-// Sprite1 Zno shadowing 2 %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_no_shadowing_2__ (p0,p1) {
 return "discard shadow 2";
@@ -19,15 +19,15 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "v", nu
 retire(); return;
 }; })

-// Sprite1 Wreturn stops the script immediately
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["PsAI*C{QHI3*4?O8p#TM"];
 const b1 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_return_stops_the_scr () {
 b0.value = 0;
 for (var a0 = 100; a0 >= 0.5; a0--) {
-b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 25)) {
+b0.value = (b0.value + 1);
+if ((b0.value === 25)) {
 return "stopped!";
 }
 }
@@ -42,7 +42,7 @@ return function* genXYZ () {
 b0.value = 0;
 while (true) {
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 18)) {
+if ((b0.value === 18)) {
 retire(); return;
 }
 yield;
@@ -32,7 +32,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "N", nu
 retire(); return;
 }; })

-// Sprite1 Znon warp
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -73,7 +73,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass non warp 2",}, b1, false, fa
 return "";
 }; })

-// Sprite1 Wverify runs warp %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -95,7 +95,7 @@ return ("warp: " + ("" + p0));
 return "";
 }; })

-// Sprite1 Zverify runs non warp %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -18,7 +18,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "$R-1lb
 retire(); return;
 }; })

-// Sprite1 Zswitch %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_switch_ (p0) {
 runtime.ext_scratch3_looks._setCostume(target, p0);
@@ -36,7 +36,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass direction",}, b0, false, fal
 if (((b2 ? b2.currentCostume + 1 : 0) === 3)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass costume #",}, b0, false, false, "+zO[+f?c7F`ZGTbD.oqI", null);
 }
-if ((("" + (b2 ? b2.getCostumes()[b2.currentCostume].name : 0)).toLowerCase() === "Costume name test".toLowerCase())) {
+if (((b2 ? b2.getCostumes()[b2.currentCostume].name : 0).toLowerCase() === "Costume name test".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass costume name",}, b0, false, false, "Y6L|T0Pvwsct2gq+HGvv", null);
 }
 if (((b2 ? b2.size : 0) === 76.01)) {
@@ -52,7 +52,7 @@ if (compareEqual((b4 ? b4.value : 0), 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non existent variable",}, b0, false, false, ")nnN?*l+E)dC(fT5(_@q", null);
 }
 b5.value = (("" + randomInt(1, 9)) + ("" + randomInt(1, 9)));
-if (compareEqual(runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: b5.value, PROPERTY: "backdrop #" }), 0)) {
+if (compareEqual(runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: ("" + b5.value), PROPERTY: "backdrop #" }), 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass NE backdrop #",}, b0, false, false, "UFr{fbR3@a.u_paq:r]F", null);
 }
 if (compareEqual(runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: ("" + b5.value), PROPERTY: "backdrop name" }), 0)) {
@@ -29,7 +29,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass \\t and other spaces = strin
 if (compareEqual(b0.value, (0 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass \\t in a variable = number 0",}, b1, false, false, "z", null);
 }
-if (compareEqual("\t", (0 + 0))) {
+if ((0 === (0 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass literal \\t = number 0",}, b1, false, false, "B", null);
 }
 if (compareEqual(("    " + ("" + b0.value)), (0 + 0))) {
@@ -6,31 +6,31 @@
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 15",}, b0, false, false, "p", null);
-if (compareEqual(tan(0), 0)) {
+if (((tan(0) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 0",}, b0, false, false, "O", null);
 }
 if (((tan(90) || 0) === Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 90",}, b0, false, false, "G", null);
 }
-if (compareEqual(tan(180), 0)) {
+if (((tan(180) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 180",}, b0, false, false, "I", null);
 }
 if (((tan(270) || 0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 270",}, b0, false, false, "K", null);
 }
-if (compareEqual(tan(360), 0)) {
+if (((tan(360) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 360",}, b0, false, false, "M", null);
 }
 if (((tan(450) || 0) === Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 450",}, b0, false, false, "Q", null);
 }
-if (compareEqual(tan(540), 0)) {
+if (((tan(540) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 540",}, b0, false, false, "S", null);
 }
 if (((tan(630) || 0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 630",}, b0, false, false, "U", null);
 }
-if (compareEqual(tan(720), 0)) {
+if (((tan(720) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 720",}, b0, false, false, "W", null);
 }
 if (((tan(810) || 0) === Infinity)) {
@@ -39,13 +39,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass 810",}, b0, false, false, "Y
 if (((tan(-90) || 0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -90",}, b0, false, false, "0", null);
 }
-if (compareEqual(tan(-180), 0)) {
+if (((tan(-180) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -180",}, b0, false, false, "2", null);
 }
 if (((tan(-270) || 0) === Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -270",}, b0, false, false, "4", null);
 }
-if (compareEqual(tan(-360), 0)) {
+if (((tan(-360) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -360",}, b0, false, false, "6", null);
 }
 if (((tan(-450) || 0) === -Infinity)) {
@@ -15,23 +15,23 @@ if ((10 === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 2",}, b0, false, false, "@A5}x{mm-Gk?CVz3o0Yn", null);
 }
 b1.value = 10;
-if (((+b1.value || 0) === 10)) {
+if ((b1.value === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 3",}, b0, false, false, "Ul:BCck-}Fvdux~x#$${", null);
 }
-if (compareEqual(b1.value, "010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 4",}, b0, false, false, "8]2$7P)o#+#Lo]mFSBbx", null);
 }
-if (compareEqual(b1.value, "0000000010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 5",}, b0, false, false, "ZU^{OfKTg|+Au$$q0[]u", null);
 }
 for (var a0 = 1; a0 >= 0.5; a0--) {
 if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 6",}, b0, false, false, "HB+_IN}6=K[*ksxKXH0`", null);
 }
-if (compareEqual(b1.value, "010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 7",}, b0, false, false, ";73ODiwcp8IthYURTX;S", null);
 }
-if (compareEqual(b1.value, "0000000010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 8",}, b0, false, true, "${[MFmBL-D*1rbas9Q89", null);
 if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 }
@@ -41,20 +41,20 @@ b2.value = "010";
 if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 9",}, b0, false, false, "#.`@SBj!g-c0:_q/tMZo", null);
 }
-if (compareEqual(b2.value, "010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 10",}, b0, false, false, "B`o?V6/q6g),/2w};a#y", null);
 }
-if (compareEqual(b2.value, "0000000010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 11",}, b0, false, false, "TJ:#TkYBys*!RYiKLXb)", null);
 }
 for (var a1 = 1; a1 >= 0.5; a1--) {
 if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 12",}, b0, false, false, ",Z,~10Qo~j;(+VL+I3q:", null);
 }
-if (compareEqual(b2.value, "010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 13",}, b0, false, false, "|Mqx([(26M%#ggW9)U0s", null);
 }
-if (compareEqual(b2.value, "0000000010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 14",}, b0, false, true, "YvtiKF231lU8p5Qd97RP", null);
 if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 }
@@ -69,16 +69,16 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "XzQt!
 if ((0 === 1)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "rxZqw7cv8g;PDM4B%{`?", null);
 }
-if (compareEqual(" ", 0)) {
+if ((" ".toLowerCase() === "0".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "3G|)eVw1mQm;O~cRy`}0", null);
 }
-if (compareEqual(0, " ")) {
+if (("0".toLowerCase() === " ".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "sd5xXX*tsW/~A_Q!0;^w", null);
 }
-if (compareEqual("", 0)) {
+if (("".toLowerCase() === "0".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "7**baE=].WD9OoY1+IEu", null);
 }
-if (compareEqual(0, "")) {
+if (("0".toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "7!IB!=o/2H.Jqj-8Vwhz", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "df{tf!WhfRwXgQ?SN_dj", null);
@@ -11,14 +11,14 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "s", nu
 retire(); return;
 }; })

-// Sprite1 Wrun without screen refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["F?*}X,`9XBpN_[piGRrz"];
 const b1 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_run_without_screen_r () {
-b0.value = (((daysSince2000() * 86400) || 0) + 3);
+b0.value = ((daysSince2000() * 86400) + 3);
 runtime.ioDevices.clock.resetProjectTimer();
-while (!((runtime.ioDevices.clock.projectTimer() > 0.1) || compareGreaterThan((daysSince2000() * 86400), b0.value))) {
+while (!((runtime.ioDevices.clock.projectTimer() > 0.1) || ((daysSince2000() * 86400) > b0.value))) {
 if (isStuck()) yield;
 }
 if (compareLessThan((daysSince2000() * 86400), b0.value)) {
@@ -10,7 +10,7 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, ",a.euo_AgQTxR+D^x0M0", null);
 b1.value = 0;
 b2.value = "";
-while (!compareGreaterThan(b2.value, "")) {
+while (!(b2.value.toLowerCase() > "".toLowerCase())) {
 startHats("event_whenbroadcastreceived", { BROADCAST_OPTION: "step" });
 yield;
 }
@@ -25,7 +25,7 @@ const b0 = stage.variables["7qur6!bGgvC9I(Nd5.HP"];
 const b1 = stage.variables["sUOp@-6J4y0PqwiXit4!"];
 return function* genXYZ () {
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 5)) {
+if ((b0.value === 5)) {
 b1.value = "end";
 }
 retire(); return;
@@ -17,7 +17,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 1)) {
+if ((b0.value === 1)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (1)",}, b2, false, false, "]4hbk*5ix]V00h|!x1oy", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 1 != " + ("" + b0.value)),}, b2, false, false, "H=x@7SpNJeX|!}8x5y4,", null);
@@ -75,7 +75,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 2)) {
+if ((b0.value === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (2)",}, b2, false, false, "0i[-T:vYTt=bi47@byUE", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 2 != " + ("" + b0.value)),}, b2, false, false, "Coc1aZ;L9M-RyEt`syps", null);
@@ -51,7 +51,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 1)) {
+if ((b0.value === 1)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (1)",}, b2, false, false, "RSQ{nVCc)6E)(`KlnFCF", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 1 != " + ("" + b0.value)),}, b2, false, false, "8k^j~`c^|YO@hkFd?~2d", null);
@@ -75,7 +75,7 @@ yield;
 }
 thread.timer = null;
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 2)) {
+if ((b0.value === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass order is correct (2)",}, b2, false, false, "KP?op(=Vg2#;@]!,C#.~", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail order is incorrect 2 != " + ("" + b0.value)),}, b2, false, false, "=]|}L~4uQXTNtwJKw_;R", null);
@@ -9,61 +9,61 @@ yield* executeInCompatibilityLayer({"MESSAGE":"plan 20",}, b0, false, false, "v"
 if ((("" + (0 * Infinity)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "6", null);
 }
-if (compareEqual((((0 * Infinity) || 0) * 1), 0)) {
+if (((((0 * Infinity) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "#", null);
 }
 if ((("" + ((Math.acos(1.01) * 180) / Math.PI)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "9", null);
 }
-if (compareEqual(((((Math.acos(1.01) * 180) / Math.PI) || 0) * 1), 0)) {
+if ((((((Math.acos(1.01) * 180) / Math.PI) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "(", null);
 }
 if ((("" + ((Math.asin(1.01) * 180) / Math.PI)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "*", null);
 }
-if (compareEqual(((((Math.asin(1.01) * 180) / Math.PI) || 0) * 1), 0)) {
+if ((((((Math.asin(1.01) * 180) / Math.PI) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, ",", null);
 }
 if ((("" + (0 / 0)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, ".", null);
 }
-if (compareEqual((((0 / 0) || 0) * 1), 0)) {
+if (((((0 / 0) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, ":", null);
 }
 if ((("" + Math.sqrt(-1)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "?", null);
 }
-if (compareEqual(((Math.sqrt(-1) || 0) * 1), 0)) {
+if ((((Math.sqrt(-1) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "@", null);
 }
 if ((("" + mod(0, 0)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "]", null);
 }
-if (compareEqual(((mod(0, 0) || 0) * 1), 0)) {
+if ((((mod(0, 0) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "_", null);
 }
 if ((("" + Math.log(-1)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "{", null);
 }
-if (compareEqual(((Math.log(-1) || 0) * 1), 0)) {
+if ((((Math.log(-1) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "}", null);
 }
 if ((("" + (Math.log(-1) / Math.LN10)).toLowerCase() === "NaN".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "aa", null);
 }
-if (compareEqual((((Math.log(-1) / Math.LN10) || 0) * 1), 0)) {
+if (((((Math.log(-1) / Math.LN10) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ac", null);
 }
-if (compareEqual((((Math.round(Math.sin((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1), 0)) {
+if (((((Math.round(Math.sin((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ae", null);
 }
-if (compareEqual((((Math.round(Math.cos((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1), 0)) {
+if (((((Math.round(Math.cos((Math.PI * ((1 / 0) || 0)) / 180) * 1e10) / 1e10) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ag", null);
 }
-if (compareEqual(((tan(((1 / 0) || 0)) || 0) * 1), 0)) {
+if ((((tan(((1 / 0) || 0)) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ai", null);
 }
-if (compareEqual(((runtime.ext_scratch3_operators._random((-1 / 0), (1 / 0)) || 0) * 1), 0)) {
+if ((((runtime.ext_scratch3_operators._random((-1 / 0), (1 / 0)) || 0) * 1) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "ak", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "7", null);
@@ -11,7 +11,7 @@ target.setSize(96);
 b1.value = 0;
 while (!(100 === Math.round(target.size))) {
 b1.value = ((+b1.value || 0) + 1);
-target.setSize(target.size + ((((100 - Math.round(target.size)) || 0) / 10) || 0));
+target.setSize(target.size + ((100 - Math.round(target.size)) / 10));
 yield;
 }
 if (((+b1.value || 0) === 20)) {
@@ -8,7 +8,7 @@ const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "c", null);
 b1.value = "#22388a";
-if ((("" + b1.value).toLowerCase() === "#22388a".toLowerCase())) {
+if ((b1.value.toLowerCase() === "#22388a".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "f", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "e", null);
@@ -123,13 +123,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 38: 0 should be = 🎉",}, b
 if (!(("" + ("0".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 39: 0 should be > 🎉",}, b0, false, false, "uq", null);
 }
-if (!(("" + compareLessThan(0, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 40: 0 should be < ",}, b0, false, false, "us", null);
 }
-if (!(("" + compareEqual(0, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0".toLowerCase() === "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 41: 0 should be = ",}, b0, false, false, "uu", null);
 }
-if (!(("" + compareGreaterThan(0, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("0".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 42: 0 should be > ",}, b0, false, false, "uw", null);
 }
 if (!(("" + (0 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -249,13 +249,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 80: 0.0 should be = 🎉",},
 if (!(("" + ("0.0".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 81: 0.0 should be > 🎉",}, b0, false, false, "vn", null);
 }
-if (!(("" + compareLessThan("0.0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0.0".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 82: 0.0 should be < ",}, b0, false, false, "vp", null);
 }
-if (!(("" + compareEqual("0.0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0.0".toLowerCase() === "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 83: 0.0 should be = ",}, b0, false, false, "vr", null);
 }
-if (!(("" + compareGreaterThan("0.0", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("0.0".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 84: 0.0 should be > ",}, b0, false, false, "vt", null);
 }
 if (!(("" + (1.23 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -324,7 +324,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 105: 1.23 should be > -1",},
 if (!(("" + ("1.23".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 106: 1.23 should be < true",}, b0, false, false, "v#", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 107: 1.23 should be = true",}, b0, false, false, "v(", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -333,7 +333,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 108: 1.23 should be > true",
 if (!(("" + ("1.23".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 109: 1.23 should be < false",}, b0, false, false, "v,", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 110: 1.23 should be = false",}, b0, false, false, "v.", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -342,7 +342,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 111: 1.23 should be > false"
 if (!(("" + ("1.23".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 112: 1.23 should be < NaN",}, b0, false, false, "v=", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 113: 1.23 should be = NaN",}, b0, false, false, "v@", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -360,7 +360,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 117: 1.23 should be > Infini
 if (!(("" + ("1.23".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 118: 1.23 should be < banana",}, b0, false, false, "wa", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 119: 1.23 should be = banana",}, b0, false, false, "wc", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -369,19 +369,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 120: 1.23 should be > banana
 if (!(("" + ("1.23".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 121: 1.23 should be < 🎉",}, b0, false, false, "wg", null);
 }
-if (!(("" + ("1.23".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 122: 1.23 should be = 🎉",}, b0, false, false, "wi", null);
 }
 if (!(("" + ("1.23".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 123: 1.23 should be > 🎉",}, b0, false, false, "wk", null);
 }
-if (!(("" + compareLessThan(1.23, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("1.23".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 124: 1.23 should be < ",}, b0, false, false, "wm", null);
 }
 if (!(("" + (1.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 125: 1.23 should be = ",}, b0, false, false, "wo", null);
 }
-if (!(("" + compareGreaterThan(1.23, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("1.23".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 126: 1.23 should be > ",}, b0, false, false, "wq", null);
 }
 if (!(("" + (0.23 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -450,7 +450,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 147: .23 should be > -1",},
 if (!(("" + (".23".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 148: .23 should be < true",}, b0, false, false, "w8", null);
 }
-if (!(("" + (".23".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 149: .23 should be = true",}, b0, false, false, "w!", null);
 }
 if (!(("" + (".23".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -459,7 +459,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 150: .23 should be > true",}
 if (!(("" + (".23".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 151: .23 should be < false",}, b0, false, false, "w)", null);
 }
-if (!(("" + (".23".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 152: .23 should be = false",}, b0, false, false, "w+", null);
 }
 if (!(("" + (".23".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -468,7 +468,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 153: .23 should be > false",
 if (!(("" + (".23".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 154: .23 should be < NaN",}, b0, false, false, "w/", null);
 }
-if (!(("" + (".23".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 155: .23 should be = NaN",}, b0, false, false, "w;", null);
 }
 if (!(("" + (".23".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -486,7 +486,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 159: .23 should be > Infinit
 if (!(("" + (".23".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 160: .23 should be < banana",}, b0, false, false, "w|", null);
 }
-if (!(("" + (".23".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 161: .23 should be = banana",}, b0, false, false, "w~", null);
 }
 if (!(("" + (".23".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -495,19 +495,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 162: .23 should be > banana"
 if (!(("" + (".23".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 163: .23 should be < 🎉",}, b0, false, false, "xd", null);
 }
-if (!(("" + (".23".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 164: .23 should be = 🎉",}, b0, false, false, "xf", null);
 }
 if (!(("" + (".23".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 165: .23 should be > 🎉",}, b0, false, false, "xh", null);
 }
-if (!(("" + compareLessThan(".23", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (".23".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 166: .23 should be < ",}, b0, false, false, "xj", null);
 }
-if (!(("" + compareEqual(".23", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.23 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 167: .23 should be = ",}, b0, false, false, "xl", null);
 }
-if (!(("" + compareGreaterThan(".23", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + (".23".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 168: .23 should be > ",}, b0, false, false, "xn", null);
 }
 if (!(("" + (0.123 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -576,7 +576,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 189: 0.123 should be > -1",}
 if (!(("" + ("0.123".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 190: 0.123 should be < true",}, b0, false, false, "x5", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 191: 0.123 should be = true",}, b0, false, false, "x7", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -585,7 +585,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 192: 0.123 should be > true"
 if (!(("" + ("0.123".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 193: 0.123 should be < false",}, b0, false, false, "x#", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 194: 0.123 should be = false",}, b0, false, false, "x(", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -594,7 +594,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 195: 0.123 should be > false
 if (!(("" + ("0.123".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 196: 0.123 should be < NaN",}, b0, false, false, "x,", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 197: 0.123 should be = NaN",}, b0, false, false, "x.", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -612,7 +612,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 201: 0.123 should be > Infin
 if (!(("" + ("0.123".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 202: 0.123 should be < banana",}, b0, false, false, "x_", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 203: 0.123 should be = banana",}, b0, false, false, "x{", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -621,19 +621,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 204: 0.123 should be > banan
 if (!(("" + ("0.123".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 205: 0.123 should be < 🎉",}, b0, false, false, "ya", null);
 }
-if (!(("" + ("0.123".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 206: 0.123 should be = 🎉",}, b0, false, false, "yc", null);
 }
 if (!(("" + ("0.123".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 207: 0.123 should be > 🎉",}, b0, false, false, "ye", null);
 }
-if (!(("" + compareLessThan(0.123, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("0.123".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 208: 0.123 should be < ",}, b0, false, false, "yg", null);
 }
 if (!(("" + (0.123 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 209: 0.123 should be = ",}, b0, false, false, "yi", null);
 }
-if (!(("" + compareGreaterThan(0.123, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("0.123".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 210: 0.123 should be > ",}, b0, false, false, "yk", null);
 }
 if (!(("" + (-0 < 0)).toLowerCase() === "false".toLowerCase())) {
@@ -753,13 +753,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 248: -0 should be = 🎉",},
 if (!(("" + ("-0".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 249: -0 should be > 🎉",}, b0, false, false, "zb", null);
 }
-if (!(("" + compareLessThan("-0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("-0".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 250: -0 should be < ",}, b0, false, false, "zd", null);
 }
-if (!(("" + compareEqual("-0", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("-0".toLowerCase() === "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 251: -0 should be = ",}, b0, false, false, "zf", null);
 }
-if (!(("" + compareGreaterThan("-0", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("-0".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 252: -0 should be > ",}, b0, false, false, "zh", null);
 }
 if (!(("" + (-1 < 0)).toLowerCase() === "true".toLowerCase())) {
@@ -828,7 +828,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 273: -1 should be > -1",}, b
 if (!(("" + ("-1".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 274: -1 should be < true",}, b0, false, false, "zZ", null);
 }
-if (!(("" + ("-1".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 275: -1 should be = true",}, b0, false, false, "z1", null);
 }
 if (!(("" + ("-1".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -837,7 +837,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 276: -1 should be > true",},
 if (!(("" + ("-1".toLowerCase() < "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 277: -1 should be < false",}, b0, false, false, "z5", null);
 }
-if (!(("" + ("-1".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 278: -1 should be = false",}, b0, false, false, "z7", null);
 }
 if (!(("" + ("-1".toLowerCase() > "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -846,7 +846,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 279: -1 should be > false",}
 if (!(("" + ("-1".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 280: -1 should be < NaN",}, b0, false, false, "z#", null);
 }
-if (!(("" + ("-1".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 281: -1 should be = NaN",}, b0, false, false, "z(", null);
 }
 if (!(("" + ("-1".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -864,7 +864,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 285: -1 should be > Infinity
 if (!(("" + ("-1".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 286: -1 should be < banana",}, b0, false, false, "z=", null);
 }
-if (!(("" + ("-1".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 287: -1 should be = banana",}, b0, false, false, "z@", null);
 }
 if (!(("" + ("-1".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -873,19 +873,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 288: -1 should be > banana",
 if (!(("" + ("-1".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 289: -1 should be < 🎉",}, b0, false, false, "z_", null);
 }
-if (!(("" + ("-1".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 290: -1 should be = 🎉",}, b0, false, false, "z{", null);
 }
 if (!(("" + ("-1".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 291: -1 should be > 🎉",}, b0, false, false, "z}", null);
 }
-if (!(("" + compareLessThan(-1, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("-1".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 292: -1 should be < ",}, b0, false, false, "Aa", null);
 }
 if (!(("" + (-1 === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 293: -1 should be = ",}, b0, false, false, "Ac", null);
 }
-if (!(("" + compareGreaterThan(-1, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("-1".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 294: -1 should be > ",}, b0, false, false, "Ae", null);
 }
 if (!(("" + ("true".toLowerCase() < "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -909,7 +909,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 300: true should be > 0.0",}
 if (!(("" + ("true".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 301: true should be < 1.23",}, b0, false, false, "As", null);
 }
-if (!(("" + ("true".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 302: true should be = 1.23",}, b0, false, false, "Au", null);
 }
 if (!(("" + ("true".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -918,7 +918,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 303: true should be > 1.23",
 if (!(("" + ("true".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 304: true should be < .23",}, b0, false, false, "Ay", null);
 }
-if (!(("" + ("true".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 305: true should be = .23",}, b0, false, false, "AA", null);
 }
 if (!(("" + ("true".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -927,7 +927,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 306: true should be > .23",}
 if (!(("" + ("true".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 307: true should be < 0.123",}, b0, false, false, "AE", null);
 }
-if (!(("" + ("true".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 308: true should be = 0.123",}, b0, false, false, "AG", null);
 }
 if (!(("" + ("true".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -945,7 +945,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 312: true should be > -0",},
 if (!(("" + ("true".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 313: true should be < -1",}, b0, false, false, "AQ", null);
 }
-if (!(("" + ("true".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 314: true should be = -1",}, b0, false, false, "AS", null);
 }
 if (!(("" + ("true".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -981,7 +981,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 324: true should be > NaN",}
 if (!(("" + ("true".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 325: true should be < Infinity",}, b0, false, false, "A)", null);
 }
-if (!(("" + ("true".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (1 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 326: true should be = Infinity",}, b0, false, false, "A+", null);
 }
 if (!(("" + ("true".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1035,7 +1035,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 342: false should be > 0.0",
 if (!(("" + ("false".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 343: false should be < 1.23",}, b0, false, false, "Bp", null);
 }
-if (!(("" + ("false".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 344: false should be = 1.23",}, b0, false, false, "Br", null);
 }
 if (!(("" + ("false".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1044,7 +1044,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 345: false should be > 1.23"
 if (!(("" + ("false".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 346: false should be < .23",}, b0, false, false, "Bv", null);
 }
-if (!(("" + ("false".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 347: false should be = .23",}, b0, false, false, "Bx", null);
 }
 if (!(("" + ("false".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1053,7 +1053,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 348: false should be > .23",
 if (!(("" + ("false".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 349: false should be < 0.123",}, b0, false, false, "BB", null);
 }
-if (!(("" + ("false".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 350: false should be = 0.123",}, b0, false, false, "BD", null);
 }
 if (!(("" + ("false".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1071,7 +1071,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 354: false should be > -0",}
 if (!(("" + ("false".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 355: false should be < -1",}, b0, false, false, "BN", null);
 }
-if (!(("" + ("false".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 356: false should be = -1",}, b0, false, false, "BP", null);
 }
 if (!(("" + ("false".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1107,7 +1107,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 366: false should be > NaN",
 if (!(("" + ("false".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 367: false should be < Infinity",}, b0, false, false, "B#", null);
 }
-if (!(("" + ("false".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 368: false should be = Infinity",}, b0, false, false, "B(", null);
 }
 if (!(("" + ("false".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1161,7 +1161,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 384: NaN should be > 0.0",},
 if (!(("" + ("NaN".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 385: NaN should be < 1.23",}, b0, false, false, "Cm", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 386: NaN should be = 1.23",}, b0, false, false, "Co", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1170,7 +1170,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 387: NaN should be > 1.23",}
 if (!(("" + ("NaN".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 388: NaN should be < .23",}, b0, false, false, "Cs", null);
 }
-if (!(("" + ("NaN".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 389: NaN should be = .23",}, b0, false, false, "Cu", null);
 }
 if (!(("" + ("NaN".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1179,7 +1179,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 390: NaN should be > .23",},
 if (!(("" + ("NaN".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 391: NaN should be < 0.123",}, b0, false, false, "Cy", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 392: NaN should be = 0.123",}, b0, false, false, "CA", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1197,7 +1197,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 396: NaN should be > -0",},
 if (!(("" + ("NaN".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 397: NaN should be < -1",}, b0, false, false, "CK", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 398: NaN should be = -1",}, b0, false, false, "CM", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1233,7 +1233,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 408: NaN should be > NaN",},
 if (!(("" + ("NaN".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 409: NaN should be < Infinity",}, b0, false, false, "C8", null);
 }
-if (!(("" + ("NaN".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 410: NaN should be = Infinity",}, b0, false, false, "C!", null);
 }
 if (!(("" + ("NaN".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1332,7 +1332,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 441: Infinity should be > -1
 if (!(("" + ("Infinity".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 442: Infinity should be < true",}, b0, false, false, "DN", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 443: Infinity should be = true",}, b0, false, false, "DP", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "true".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1341,7 +1341,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 444: Infinity should be > tr
 if (!(("" + ("Infinity".toLowerCase() < "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 445: Infinity should be < false",}, b0, false, false, "DT", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "false".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 446: Infinity should be = false",}, b0, false, false, "DV", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "false".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1350,7 +1350,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 447: Infinity should be > fa
 if (!(("" + ("Infinity".toLowerCase() < "NaN".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 448: Infinity should be < NaN",}, b0, false, false, "DZ", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 449: Infinity should be = NaN",}, b0, false, false, "D1", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1368,7 +1368,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 453: Infinity should be > In
 if (!(("" + ("Infinity".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 454: Infinity should be < banana",}, b0, false, false, "D#", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "banana".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 455: Infinity should be = banana",}, b0, false, false, "D(", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1377,19 +1377,19 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 456: Infinity should be > ba
 if (!(("" + ("Infinity".toLowerCase() < "🎉".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 457: Infinity should be < 🎉",}, b0, false, false, "D,", null);
 }
-if (!(("" + ("Infinity".toLowerCase() === "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 458: Infinity should be = 🎉",}, b0, false, false, "D.", null);
 }
 if (!(("" + ("Infinity".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 459: Infinity should be > 🎉",}, b0, false, false, "D:", null);
 }
-if (!(("" + compareLessThan(Infinity, "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("Infinity".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 460: Infinity should be < ",}, b0, false, false, "D=", null);
 }
 if (!(("" + (Infinity === 0)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 461: Infinity should be = ",}, b0, false, false, "D@", null);
 }
-if (!(("" + compareGreaterThan(Infinity, "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("Infinity".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 462: Infinity should be > ",}, b0, false, false, "D]", null);
 }
 if (!(("" + ("banana".toLowerCase() < "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1413,7 +1413,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 468: banana should be > 0.0"
 if (!(("" + ("banana".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 469: banana should be < 1.23",}, b0, false, false, "Eg", null);
 }
-if (!(("" + ("banana".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 470: banana should be = 1.23",}, b0, false, false, "Ei", null);
 }
 if (!(("" + ("banana".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1422,7 +1422,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 471: banana should be > 1.23
 if (!(("" + ("banana".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 472: banana should be < .23",}, b0, false, false, "Em", null);
 }
-if (!(("" + ("banana".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 473: banana should be = .23",}, b0, false, false, "Eo", null);
 }
 if (!(("" + ("banana".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1431,7 +1431,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 474: banana should be > .23"
 if (!(("" + ("banana".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 475: banana should be < 0.123",}, b0, false, false, "Es", null);
 }
-if (!(("" + ("banana".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 476: banana should be = 0.123",}, b0, false, false, "Eu", null);
 }
 if (!(("" + ("banana".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1449,7 +1449,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 480: banana should be > -0",
 if (!(("" + ("banana".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 481: banana should be < -1",}, b0, false, false, "EE", null);
 }
-if (!(("" + ("banana".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 482: banana should be = -1",}, b0, false, false, "EG", null);
 }
 if (!(("" + ("banana".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1485,7 +1485,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 492: banana should be > NaN"
 if (!(("" + ("banana".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 493: banana should be < Infinity",}, b0, false, false, "E2", null);
 }
-if (!(("" + ("banana".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 494: banana should be = Infinity",}, b0, false, false, "E4", null);
 }
 if (!(("" + ("banana".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
@@ -1539,7 +1539,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 510: 🎉 should be > 0.0",}
 if (!(("" + ("🎉".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 511: 🎉 should be < 1.23",}, b0, false, false, "Fd", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 512: 🎉 should be = 1.23",}, b0, false, false, "Ff", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1548,7 +1548,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 513: 🎉 should be > 1.23",
 if (!(("" + ("🎉".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 514: 🎉 should be < .23",}, b0, false, false, "Fj", null);
 }
-if (!(("" + ("🎉".toLowerCase() === ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 515: 🎉 should be = .23",}, b0, false, false, "Fl", null);
 }
 if (!(("" + ("🎉".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1557,7 +1557,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 516: 🎉 should be > .23",}
 if (!(("" + ("🎉".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 517: 🎉 should be < 0.123",}, b0, false, false, "Fp", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 518: 🎉 should be = 0.123",}, b0, false, false, "Fr", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1575,7 +1575,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 522: 🎉 should be > -0",},
 if (!(("" + ("🎉".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 523: 🎉 should be < -1",}, b0, false, false, "FB", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 524: 🎉 should be = -1",}, b0, false, false, "FD", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1611,7 +1611,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 534: 🎉 should be > NaN",}
 if (!(("" + ("🎉".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 535: 🎉 should be < Infinity",}, b0, false, false, "FZ", null);
 }
-if (!(("" + ("🎉".toLowerCase() === "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 536: 🎉 should be = Infinity",}, b0, false, false, "F1", null);
 }
 if (!(("" + ("🎉".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1644,67 +1644,67 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 545: 🎉 should be = ",}, b
 if (!(("" + ("🎉".toLowerCase() > "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 546: 🎉 should be > ",}, b0, false, false, "F:", null);
 }
-if (!(("" + compareLessThan("", 0)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "0".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 547:  should be < 0",}, b0, false, false, "F=", null);
 }
-if (!(("" + compareEqual("", 0)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 548:  should be = 0",}, b0, false, false, "F@", null);
 }
-if (!(("" + compareGreaterThan("", 0)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 549:  should be > 0",}, b0, false, false, "F]", null);
 }
-if (!(("" + compareLessThan("", "0.0")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "0.0".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 550:  should be < 0.0",}, b0, false, false, "F_", null);
 }
-if (!(("" + compareEqual("", "0.0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "0.0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 551:  should be = 0.0",}, b0, false, false, "F{", null);
 }
-if (!(("" + compareGreaterThan("", "0.0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "0.0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 552:  should be > 0.0",}, b0, false, false, "F}", null);
 }
-if (!(("" + compareLessThan("", 1.23)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "1.23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 553:  should be < 1.23",}, b0, false, false, "Ga", null);
 }
 if (!(("" + (0 === 1.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 554:  should be = 1.23",}, b0, false, false, "Gc", null);
 }
-if (!(("" + compareGreaterThan("", 1.23)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "1.23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 555:  should be > 1.23",}, b0, false, false, "Ge", null);
 }
-if (!(("" + compareLessThan("", ".23")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < ".23".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 556:  should be < .23",}, b0, false, false, "Gg", null);
 }
-if (!(("" + compareEqual("", ".23")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + (0 === 0.23)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 557:  should be = .23",}, b0, false, false, "Gi", null);
 }
-if (!(("" + compareGreaterThan("", ".23")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > ".23".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 558:  should be > .23",}, b0, false, false, "Gk", null);
 }
-if (!(("" + compareLessThan("", 0.123)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "0.123".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 559:  should be < 0.123",}, b0, false, false, "Gm", null);
 }
 if (!(("" + (0 === 0.123)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 560:  should be = 0.123",}, b0, false, false, "Go", null);
 }
-if (!(("" + compareGreaterThan("", 0.123)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "0.123".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 561:  should be > 0.123",}, b0, false, false, "Gq", null);
 }
-if (!(("" + compareLessThan("", "-0")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "-0".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 562:  should be < -0",}, b0, false, false, "Gs", null);
 }
-if (!(("" + compareEqual("", "-0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "-0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 563:  should be = -0",}, b0, false, false, "Gu", null);
 }
-if (!(("" + compareGreaterThan("", "-0")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "-0".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 564:  should be > -0",}, b0, false, false, "Gw", null);
 }
-if (!(("" + compareLessThan("", -1)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "-1".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 565:  should be < -1",}, b0, false, false, "Gy", null);
 }
 if (!(("" + (0 === -1)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 566:  should be = -1",}, b0, false, false, "GA", null);
 }
-if (!(("" + compareGreaterThan("", -1)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "-1".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 567:  should be > -1",}, b0, false, false, "GC", null);
 }
 if (!(("" + ("".toLowerCase() < "true".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1734,13 +1734,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 575:  should be = NaN",}, b0
 if (!(("" + ("".toLowerCase() > "NaN".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 576:  should be > NaN",}, b0, false, false, "GU", null);
 }
-if (!(("" + compareLessThan("", Infinity)).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "Infinity".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 577:  should be < Infinity",}, b0, false, false, "GW", null);
 }
 if (!(("" + (0 === Infinity)).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 578:  should be = Infinity",}, b0, false, false, "GY", null);
 }
-if (!(("" + compareGreaterThan("", Infinity)).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "Infinity".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 579:  should be > Infinity",}, b0, false, false, "G0", null);
 }
 if (!(("" + ("".toLowerCase() < "banana".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
@@ -1761,13 +1761,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail 584:  should be = 🎉",}, b
 if (!(("" + ("".toLowerCase() > "🎉".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 585:  should be > 🎉",}, b0, false, false, "G%", null);
 }
-if (!(("" + compareLessThan("", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() < "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 586:  should be < ",}, b0, false, false, "G)", null);
 }
-if (!(("" + compareEqual("", "")).toLowerCase() === "true".toLowerCase())) {
+if (!(("" + ("".toLowerCase() === "".toLowerCase())).toLowerCase() === "true".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 587:  should be = ",}, b0, false, false, "G+", null);
 }
-if (!(("" + compareGreaterThan("", "")).toLowerCase() === "false".toLowerCase())) {
+if (!(("" + ("".toLowerCase() > "".toLowerCase())).toLowerCase() === "false".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail 588:  should be > ",}, b0, false, false, "G.", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "G-", null);
@@ -11,7 +11,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "aZ", n
 retire(); return;
 }; })

-// Sprite1 Wrun test
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["mfV;yS}9e:%h5UZ)QyiY"];
 const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
@@ -29,15 +29,15 @@ b3.value = 0;
 for (var a1 = b2.value.length; a1 >= 0.5; a1--) {
 b3.value = ((+b3.value || 0) + 1);
 b0.value = ((+b0.value || 0) + 1);
-if (!compareEqual(compareGreaterThan(listGet(b2.value, b1.value), (b2.value[((b3.value || 0) | 0) - 1] ?? "")), (b4.value[((b0.value || 0) | 0) - 1] ?? ""))) {
-yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be > " + ("" + listGet(b2.value, b3.value))))),}, b5, true, false, "]", null);
+if (!compareEqual(compareGreaterThan(listGet(b2.value, b1.value), (b2.value[(b3.value | 0) - 1] ?? "")), (b4.value[(b0.value | 0) - 1] ?? ""))) {
+yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be > " + ("" + (b2.value[(b3.value | 0) - 1] ?? ""))))),}, b5, true, false, "]", null);
 }
 b0.value = ((+b0.value || 0) + 1);
-if (!compareEqual(compareEqual(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[((b0.value || 0) | 0) - 1] ?? ""))) {
+if (!compareEqual(compareEqual(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[(b0.value | 0) - 1] ?? ""))) {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be = " + ("" + listGet(b2.value, b3.value))))),}, b5, true, false, "|", null);
 }
 b0.value = ((+b0.value || 0) + 1);
-if (!compareEqual(compareLessThan(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[((b0.value || 0) | 0) - 1] ?? ""))) {
+if (!compareEqual(compareLessThan(listGet(b2.value, b1.value), listGet(b2.value, b3.value)), (b4.value[(b0.value | 0) - 1] ?? ""))) {
 yield* executeInCompatibilityLayer({"MESSAGE":("fail " + (("" + listGet(b2.value, b1.value)) + (" should be < " + ("" + listGet(b2.value, b3.value))))),}, b5, true, true, "ab", null);
 if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 }
@@ -48,7 +48,7 @@ if (isStuck()) yield;
 return "";
 }; })

-// Sprite1 Wsetup values
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["n^wm8jw#b24sggt.S^tD"];
 return function funXYZ_setup_values () {
@@ -107,7 +107,7 @@ b0.value.push((-1 / 0));
 b0._monitorUpToDate = false;
 b0.value.push((0 / 0));
 b0._monitorUpToDate = false;
-b0.value.push(NaN);
+b0.value.push("NaN");
 b0._monitorUpToDate = false;
 b0.value.push("nan");
 b0._monitorUpToDate = false;
@@ -19,7 +19,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "l", nu
 retire(); return;
 }; })

-// Sprite1 Zblock name
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_block_name () {
 return 40;
@@ -12,10 +12,10 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "k", n
 if (compareLessThan(("something".toLowerCase() === "else".toLowerCase()), ("1" + ""))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "m", null);
 }
-if (compareGreaterThan(("something".toLowerCase() === "something".toLowerCase()), (0 + 0))) {
+if (((+("something".toLowerCase() === "something".toLowerCase())) > (0 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "n", null);
 }
-if (compareLessThan(("something".toLowerCase() === "else".toLowerCase()), (1 + 0))) {
+if (((+("something".toLowerCase() === "else".toLowerCase())) < (1 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "o", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "l", null);
@@ -9,13 +9,13 @@ const b2 = target.variables["zShM`!CD?d_|Z,]5X}N6"];
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 2",}, b0, false, false, "d", null);
 b1.value = 2;
-if (((+b1.value || 0) === 2)) {
+if ((b1.value === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass variable",}, b0, false, false, "k", null);
 }
 b2.value = [];
 b2.value.push(3);
 b2._monitorUpToDate = false;
-if (((+(b2.value[(1 | 0) - 1] ?? "") || 0) === 3)) {
+if (((+(b2.value[1 - 1] ?? "") || 0) === 3)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass list",}, b0, false, false, "m", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "l", null);
@@ -21,7 +21,7 @@ retire(); return;
 retire(); return;
 }; })

-// Sprite1 Wno refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("music_restForBeats");
 const b1 = runtime.getOpcodeFunction("music_playDrumForBeats");
@@ -42,14 +42,14 @@ if (isStuck()) yield;
 return "";
 }; })

-// Sprite1 Wruns below with no refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function* genXYZ_runs_below_with_no_r () {
 yield* thread.procedures["Whas refresh"]();
 return "";
 }; })

-// Sprite1 Whas refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("music_restForBeats");
 const b1 = runtime.getOpcodeFunction("music_playDrumForBeats");
@@ -11,14 +11,14 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "g", nu
 retire(); return;
 }; })

-// Sprite1 Zfoo %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_foo_ (p0) {
 return "";
 return "";
 }; })

-// Sprite1 Zno op
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_no_op () {
 return "";
@@ -30,7 +30,7 @@ listDelete(b1, "any");
 if ((b1.value.length === 2)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "C", null);
 }
-if (compareEqual(listGet(b1.value, "*"), "")) {
+if ((("" + listGet(b1.value, "*")).toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "F", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "E", null);
@@ -6,7 +6,7 @@
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "@|B*yJ0zKh!acN`7L-N5", null);
-if ((((1 / -0) || 0) === -Infinity)) {
+if (((1 / -0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "=enYDFG11Nj/0BL:y56w", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, ",Cpv8W0RH0RgNky[1xb:", null);
@@ -11,7 +11,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "Q^(MKg
 retire(); return;
 }; })

-// Player ZSet Costume
+// Player script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_Set_Costume () {
@@ -12,7 +12,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "$R-1lb
 retire(); return;
 }; })

-// Sprite1 Znumber or text %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_number_or_text__ (p0,p1) {
@@ -22,7 +22,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "HH`yR
 return "";
 }; })

-// Sprite1 Zboolean %b %b
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_boolean__ (p0,p1) {
@@ -9,14 +9,14 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "qf{MD}-f+l?U+)KA#Vnm", null);
 b1.value = "";
 thread.procedures["Zdo something"]();
-if (!compareEqual(b1.value, "")) {
+if (!(b1.value.toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass",}, b0, false, false, "Sgf_#7|GOpx!R]?Q3]$s", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, ",vD-ZG7f{]FoJ`,))JWh", null);
 retire(); return;
 }; })

-// Sprite1 Zdo something
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
 return function funXYZ_do_something () {
@@ -39,14 +39,14 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "P", nu
 retire(); return;
 }; })

-// Sprite1 Zinvalid params - reporter
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_invalid_params___rep () {
 return 0;
 return "";
 }; })

-// Sprite1 Zinvalid params - boolean
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_invalid_params___boo () {
 return 0;
@@ -9,7 +9,7 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, "d", null);
 b1.value = "discard me";
 b1.value = "";
-if (compareEqual(b1.value, "")) {
+if ((("" + b1.value).toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non existent procedure returned empty string",}, b0, false, false, "h", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "g", null);
@@ -10,17 +10,17 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 18",}, b0, false, false, "G", null);
 b1.value = 0;
 b2.value = (yield* thread.procedures["Znon warp recursion should yield %s"](8));
-if (((+b1.value || 0) === 4)) {
+if ((b1.value === 4)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non warp recursion yields",}, b0, false, false, "ao", null);
 }
 b1.value = 0;
 b2.value = thread.procedures["Wwarp recursion should not yield %s"](8);
-if (((+b1.value || 0) === 0)) {
+if ((b1.value === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass warp recursion does not yield",}, b0, false, false, "ar", null);
 }
 b1.value = 0;
 b2.value = (yield* thread.procedures["Zfib %s"](7));
-if (((+b1.value || 0) === 20)) {
+if ((b1.value === 20)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non warp fib yielded",}, b0, false, false, "au", null);
 }
 yield* thread.procedures["Zrecursing yields between each %s"]("initial");
@@ -30,7 +30,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "av", n
 retire(); return;
 }; })

-// Sprite1 Znon warp recursion should yield %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function* genXYZ_non_warp_recursion_s (p0) {
 if (compareGreaterThan(p0, 0)) {
@@ -39,7 +39,7 @@ return (yield* yieldThenCallGenerator(thread.procedures["Znon warp recursion sho
 return "";
 }; })

-// Sprite1 Wwarp recursion should not yield %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_warp_recursion_shoul (p0) {
 if (compareGreaterThan(p0, 0)) {
@@ -48,7 +48,7 @@ return thread.procedures["Wwarp recursion should not yield %s"](((+p0 || 0) - 1)
 return "";
 }; })

-// Sprite1 Zfib %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function* genXYZ_fib_ (p0) {
 if (compareLessThan(p0, 2)) {
@@ -59,7 +59,7 @@ return ((+(yield* yieldThenCallGenerator(thread.procedures["Zfib %s"], ((+p0 ||
 return "";
 }; })

-// Sprite1 Zrecursing yields between each %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
@@ -68,7 +68,7 @@ return function* genXYZ_recursing_yields_bet (p0) {
 if ((("" + p0).toLowerCase() === "initial".toLowerCase())) {
 b0.value = 0;
 b1.value = ((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 1)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 1)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 2)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 2)) || 0) + (((+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 3)) || 0) + (+(yield* yieldThenCallGenerator(thread.procedures["Zrecursing yields between each %s"], 3)) || 0)) || 0)) || 0)) || 0)) || 0));
-if (((+b0.value || 0) === 3)) {
+if ((b0.value === 3)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recursing between calls yields final",}, b2, false, false, "aK", null);
 } else {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail recursing between calls yields final",}, b2, false, false, "aL", null);
@@ -83,7 +83,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":("fail recursing between calls yie
 return "";
 }; })

-// Sprite1 Zrecursing arguments eval order %s %s %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["4HH82mPlVMOONdl(Ot*7"];
 const b1 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
@@ -94,25 +94,25 @@ if ((("" + p0).toLowerCase() === "initial".toLowerCase())) {
 b0.value = [];
 b1.value = 0;
 b2.value = (yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 1",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 2",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 3",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 4","","","")),(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 5","","","")),(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 6","","","")))),"","")),"",(yield* yieldThenCallGenerator(thread.procedures["Zrecursing arguments eval order %s %s %s %s"], "child 7","","",""))));
-if ((("" + (b0.value[(1 | 0) - 1] ?? "")).toLowerCase() === "1/child 4".toLowerCase())) {
+if ((("" + (b0.value[1 - 1] ?? "")).toLowerCase() === "1/child 4".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 1",}, b3, false, false, "aZ", null);
 }
-if ((("" + (b0.value[(2 | 0) - 1] ?? "")).toLowerCase() === "1/child 5".toLowerCase())) {
+if ((("" + (b0.value[2 - 1] ?? "")).toLowerCase() === "1/child 5".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 2",}, b3, false, false, "a#", null);
 }
-if ((("" + (b0.value[(3 | 0) - 1] ?? "")).toLowerCase() === "2/child 6".toLowerCase())) {
+if ((("" + (b0.value[3 - 1] ?? "")).toLowerCase() === "2/child 6".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 3",}, b3, false, false, "a(", null);
 }
-if ((("" + (b0.value[(4 | 0) - 1] ?? "")).toLowerCase() === "2/child 3".toLowerCase())) {
+if ((("" + (b0.value[4 - 1] ?? "")).toLowerCase() === "2/child 3".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 4",}, b3, false, false, "a*", null);
 }
-if ((("" + (b0.value[(5 | 0) - 1] ?? "")).toLowerCase() === "3/child 2".toLowerCase())) {
+if ((("" + (b0.value[5 - 1] ?? "")).toLowerCase() === "3/child 2".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 5",}, b3, false, false, "a,", null);
 }
-if ((("" + (b0.value[(6 | 0) - 1] ?? "")).toLowerCase() === "3/child 7".toLowerCase())) {
+if ((("" + (b0.value[6 - 1] ?? "")).toLowerCase() === "3/child 7".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 6",}, b3, false, false, "a.", null);
 }
-if ((("" + (b0.value[(7 | 0) - 1] ?? "")).toLowerCase() === "4/child 1".toLowerCase())) {
+if ((("" + (b0.value[7 - 1] ?? "")).toLowerCase() === "4/child 1".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass recurse arg order - 7",}, b3, false, false, "a:", null);
 }
 if ((b0.value.length === 7)) {
@@ -20,21 +20,21 @@ if (((+thread.procedures["Wfactorial %s"](12) || 0) === 479001600)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass factorial 12",}, b0, false, false, "]", null);
 }
 b1.value = (yield* thread.procedures["Zno shadowing 1 %s %s"]("f","g"));
-if (compareEqual(b1.value, "")) {
+if ((("" + b1.value).toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass default return value",}, b0, false, false, "|", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "`", null);
 retire(); return;
 }; })

-// Sprite1 Zsimplest
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_simplest () {
 return "It works!";
 return "";
 }; })

-// Sprite1 Znesting 1
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_nesting_1 () {
 thread.procedures["Znesting 2"]();
@@ -42,14 +42,14 @@ return (("" + thread.procedures["Znesting 3 %s %s"](6,7)) + ("" + thread.procedu
 return "";
 }; })

-// Sprite1 Wwarp fib %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_warp_fib_ (p0) {
 return thread.procedures["Wfib %s"](p0);
 return "";
 }; })

-// Sprite1 Wfactorial %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_factorial_ (p0) {
 if (compareGreaterThan(p0, 1)) {
@@ -59,7 +59,7 @@ return 1;
 return "";
 }; })

-// Sprite1 Zno shadowing 1 %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = runtime.getOpcodeFunction("looks_say");
 const b1 = stage.variables["`jEk@4|i[#Fk?(8x)AV.-my variable"];
@@ -78,21 +78,21 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass shadow check 3",}, b0, false
 return "";
 }; })

-// Sprite1 Znesting 2
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_nesting_2 () {
 return "discard nesting 2";
 return "";
 }; })

-// Sprite1 Znesting 3 %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_nesting_3__ (p0,p1) {
 return ((+p0 || 0) * (+p1 || 0));
 return "";
 }; })

-// Sprite1 Wfib %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_fib_ (p0) {
 if (compareLessThan(p0, 2)) {
@@ -103,7 +103,7 @@ return ((+thread.procedures["Wfib %s"](((+p0 || 0) - 1)) || 0) + (+thread.proced
 return "";
 }; })

-// Sprite1 Zno shadowing 2 %s %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_no_shadowing_2__ (p0,p1) {
 return "discard shadow 2";
@@ -19,7 +19,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "v", nu
 retire(); return;
 }; })

-// Sprite1 Wreturn stops the script immediately
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["PsAI*C{QHI3*4?O8p#TM"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -27,7 +27,7 @@ return function* genXYZ_return_stops_the_scr () {
 b0.value = 0;
 for (var a0 = 100; a0 >= 0.5; a0--) {
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 25)) {
+if ((b0.value === 25)) {
 return "stopped!";
 }
 if (isStuck()) yield;
@@ -43,7 +43,7 @@ return function* genXYZ () {
 b0.value = 0;
 while (true) {
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 18)) {
+if ((b0.value === 18)) {
 retire(); return;
 }
 yield;
@@ -32,7 +32,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "N", nu
 retire(); return;
 }; })

-// Sprite1 Znon warp
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -73,7 +73,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass non warp 2",}, b1, false, fa
 return "";
 }; })

-// Sprite1 Wverify runs warp %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -96,7 +96,7 @@ return ("warp: " + ("" + p0));
 return "";
 }; })

-// Sprite1 Zverify runs non warp %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["Go=PJS7BFXYo_qi2S:kQ"];
 const b1 = runtime.getOpcodeFunction("looks_say");
@@ -18,7 +18,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "$R-1lb
 retire(); return;
 }; })

-// Sprite1 Zswitch %s
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 return function funXYZ_switch_ (p0) {
 runtime.ext_scratch3_looks._setCostume(target, p0);
@@ -36,7 +36,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass direction",}, b0, false, fal
 if (((b2 ? b2.currentCostume + 1 : 0) === 3)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass costume #",}, b0, false, false, "+zO[+f?c7F`ZGTbD.oqI", null);
 }
-if ((("" + (b2 ? b2.getCostumes()[b2.currentCostume].name : 0)).toLowerCase() === "Costume name test".toLowerCase())) {
+if (((b2 ? b2.getCostumes()[b2.currentCostume].name : 0).toLowerCase() === "Costume name test".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass costume name",}, b0, false, false, "Y6L|T0Pvwsct2gq+HGvv", null);
 }
 if (((b2 ? b2.size : 0) === 76.01)) {
@@ -52,7 +52,7 @@ if (compareEqual((b4 ? b4.value : 0), 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass non existent variable",}, b0, false, false, ")nnN?*l+E)dC(fT5(_@q", null);
 }
 b5.value = (("" + randomInt(1, 9)) + ("" + randomInt(1, 9)));
-if (compareEqual(runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: b5.value, PROPERTY: "backdrop #" }), 0)) {
+if (compareEqual(runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: ("" + b5.value), PROPERTY: "backdrop #" }), 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass NE backdrop #",}, b0, false, false, "UFr{fbR3@a.u_paq:r]F", null);
 }
 if (compareEqual(runtime.ext_scratch3_sensing.getAttributeOf({OBJECT: ("" + b5.value), PROPERTY: "backdrop name" }), 0)) {
@@ -29,7 +29,7 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass \\t and other spaces = strin
 if (compareEqual(b0.value, (0 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass \\t in a variable = number 0",}, b1, false, false, "z", null);
 }
-if (compareEqual("\t", (0 + 0))) {
+if ((0 === (0 + 0))) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass literal \\t = number 0",}, b1, false, false, "B", null);
 }
 if (compareEqual(("    " + ("" + b0.value)), (0 + 0))) {
@@ -6,31 +6,31 @@
 const b0 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 15",}, b0, false, false, "p", null);
-if (compareEqual(tan(0), 0)) {
+if (((tan(0) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 0",}, b0, false, false, "O", null);
 }
 if (((tan(90) || 0) === Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 90",}, b0, false, false, "G", null);
 }
-if (compareEqual(tan(180), 0)) {
+if (((tan(180) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 180",}, b0, false, false, "I", null);
 }
 if (((tan(270) || 0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 270",}, b0, false, false, "K", null);
 }
-if (compareEqual(tan(360), 0)) {
+if (((tan(360) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 360",}, b0, false, false, "M", null);
 }
 if (((tan(450) || 0) === Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 450",}, b0, false, false, "Q", null);
 }
-if (compareEqual(tan(540), 0)) {
+if (((tan(540) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 540",}, b0, false, false, "S", null);
 }
 if (((tan(630) || 0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 630",}, b0, false, false, "U", null);
 }
-if (compareEqual(tan(720), 0)) {
+if (((tan(720) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 720",}, b0, false, false, "W", null);
 }
 if (((tan(810) || 0) === Infinity)) {
@@ -39,13 +39,13 @@ yield* executeInCompatibilityLayer({"MESSAGE":"pass 810",}, b0, false, false, "Y
 if (((tan(-90) || 0) === -Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -90",}, b0, false, false, "0", null);
 }
-if (compareEqual(tan(-180), 0)) {
+if (((tan(-180) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -180",}, b0, false, false, "2", null);
 }
 if (((tan(-270) || 0) === Infinity)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -270",}, b0, false, false, "4", null);
 }
-if (compareEqual(tan(-360), 0)) {
+if (((tan(-360) || 0) === 0)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass -360",}, b0, false, false, "6", null);
 }
 if (((tan(-450) || 0) === -Infinity)) {
@@ -15,23 +15,23 @@ if ((10 === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 2",}, b0, false, false, "@A5}x{mm-Gk?CVz3o0Yn", null);
 }
 b1.value = 10;
-if (((+b1.value || 0) === 10)) {
+if ((b1.value === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 3",}, b0, false, false, "Ul:BCck-}Fvdux~x#$${", null);
 }
-if (compareEqual(b1.value, "010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 4",}, b0, false, false, "8]2$7P)o#+#Lo]mFSBbx", null);
 }
-if (compareEqual(b1.value, "0000000010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 5",}, b0, false, false, "ZU^{OfKTg|+Au$$q0[]u", null);
 }
 for (var a0 = 1; a0 >= 0.5; a0--) {
 if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 6",}, b0, false, false, "HB+_IN}6=K[*ksxKXH0`", null);
 }
-if (compareEqual(b1.value, "010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 7",}, b0, false, false, ";73ODiwcp8IthYURTX;S", null);
 }
-if (compareEqual(b1.value, "0000000010")) {
+if (((+b1.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 8",}, b0, false, true, "${[MFmBL-D*1rbas9Q89", null);
 if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 }
@@ -41,20 +41,20 @@ b2.value = "010";
 if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 9",}, b0, false, false, "#.`@SBj!g-c0:_q/tMZo", null);
 }
-if (compareEqual(b2.value, "010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 10",}, b0, false, false, "B`o?V6/q6g),/2w};a#y", null);
 }
-if (compareEqual(b2.value, "0000000010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 11",}, b0, false, false, "TJ:#TkYBys*!RYiKLXb)", null);
 }
 for (var a1 = 1; a1 >= 0.5; a1--) {
 if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 12",}, b0, false, false, ",Z,~10Qo~j;(+VL+I3q:", null);
 }
-if (compareEqual(b2.value, "010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 13",}, b0, false, false, "|Mqx([(26M%#ggW9)U0s", null);
 }
-if (compareEqual(b2.value, "0000000010")) {
+if (((+b2.value || 0) === 10)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"pass 14",}, b0, false, true, "YvtiKF231lU8p5Qd97RP", null);
 if (hasResumedFromPromise) {hasResumedFromPromise = false;continue;}
 }
@@ -69,16 +69,16 @@ yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "XzQt!
 if ((0 === 1)) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "rxZqw7cv8g;PDM4B%{`?", null);
 }
-if (compareEqual(" ", 0)) {
+if ((" ".toLowerCase() === "0".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "3G|)eVw1mQm;O~cRy`}0", null);
 }
-if (compareEqual(0, " ")) {
+if (("0".toLowerCase() === " ".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "sd5xXX*tsW/~A_Q!0;^w", null);
 }
-if (compareEqual("", 0)) {
+if (("".toLowerCase() === "0".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "7**baE=].WD9OoY1+IEu", null);
 }
-if (compareEqual(0, "")) {
+if (("0".toLowerCase() === "".toLowerCase())) {
 yield* executeInCompatibilityLayer({"MESSAGE":"fail",}, b0, false, false, "7!IB!=o/2H.Jqj-8Vwhz", null);
 }
 yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "df{tf!WhfRwXgQ?SN_dj", null);
@@ -11,14 +11,14 @@ yield* executeInCompatibilityLayer({"MESSAGE":"end",}, b0, false, false, "s", nu
 retire(); return;
 }; })

-// Sprite1 Wrun without screen refresh
+// Sprite1 script
 (function factoryXYZ(thread) { const target = thread.target; const runtime = target.runtime; const stage = runtime.getTargetForStage();
 const b0 = stage.variables["F?*}X,`9XBpN_[piGRrz"];
 const b1 = runtime.getOpcodeFunction("looks_say");
 return function* genXYZ_run_without_screen_r () {
-b0.value = (((daysSince2000() * 86400) || 0) + 3);
+b0.value = ((daysSince2000() * 86400) + 3);
 runtime.ioDevices.clock.resetProjectTimer();
-while (!((runtime.ioDevices.clock.projectTimer() > 0.1) || compareGreaterThan((daysSince2000() * 86400), b0.value))) {
+while (!((runtime.ioDevices.clock.projectTimer() > 0.1) || ((daysSince2000() * 86400) > b0.value))) {
 if (isStuck()) yield;
 }
 if (compareLessThan((daysSince2000() * 86400), b0.value)) {
@@ -10,7 +10,7 @@ return function* genXYZ () {
 yield* executeInCompatibilityLayer({"MESSAGE":"plan 1",}, b0, false, false, ",a.euo_AgQTxR+D^x0M0", null);
 b1.value = 0;
 b2.value = "";
-while (!compareGreaterThan(b2.value, "")) {
+while (!(b2.value.toLowerCase() > "".toLowerCase())) {
 startHats("event_whenbroadcastreceived", { BROADCAST_OPTION: "step" });
 yield;
 }
@@ -25,7 +25,7 @@ const b0 = stage.variables["7qur6!bGgvC9I(Nd5.HP"];
 const b1 = stage.variables["sUOp@-6J4y0PqwiXit4!"];
 return function* genXYZ () {
 b0.value = ((+b0.value || 0) + 1);
-if (((b0.value || 0) === 5)) {
+if ((b0.value === 5)) {
 b1.value = "end";
 }
 retire(); return;