ufuzz failure

[alexlamsl]

// original code
// (beautified)
var _calls_ = 10, a = 100, b = 10, c = 0;

export async function* f0(let_2) {
    {
        var await_2 = function c_1(undefined_2) {
            {
                var brake3 = 5;
                while (23..toString() && --brake3 > 0) {}
            }
            try {
                try {
                    return delete a;
                } catch (foo) {} finally {
                    {
                        var expr8 = let_2 && typeof let_2.in == "function" && --_calls_ >= 0 && let_2.in(Number(0xdeadn << 16n | 0xbeefn), 24..toString(), (c = 1 + c, 
                        (-2 != "b") + (0 == "b") !== (c = c + 1, "number" === null)));
                        for (var key8 in expr8) {
                            try {
                            } catch (bar) {
                                c = 1 + c, ((bar && ({
                                    "\t": bar[c = 1 + c, "bar" ** undefined ^ "b" > "function" ^ (0 ^ "c") > (key8 &= "object" & {})]
                                } = {
                                    "\t": /[a2][^e]+$/ === {}
                                })) === NaN - 25) + (Infinity << "bar" || -3 << "bar");
                            }
                        }
                    }
                    a++ + [].undefined;
                    L69844: {
                    }
                }
            } catch (yield) {
                {
                    var brake17 = 5;
                    while (a++ + let_2 && --brake17 > 0) {
                        var brake18 = 5;
                        do {
                            c = c + 1;
                        } while ((c = c + 1) + {
                            async: (c = 1 + c, (!24..toString() === (undefined_2 && (undefined_2.next += 24..toString() ^ -3))) % ((c = c + 1, 
                            "a") ^ (-0 && 1))),
                            let_2: let_2,
                            value: (c = 1 + c, (undefined_2 && (undefined_2.async >>= Infinity ^ 4)) == 2 >>> [] & 1 == "a" === ("foo" & "c")),
                            [(c = 1 + c, (undefined || -1) >= ("" !== "object") ^ (undefined_2 && (undefined_2.undefined = undefined <= /[a2][^e]+$/ > (1 & -3))))]: (c = 1 + c, 
                            (4 <= false & "undefined" >>> NaN) % ((true <= "") + ({} > -2)))
                        } && --brake18 > 0);
                    }
                }
            } finally {}
            c = c + 1;
        }(a++);
    }
}

var Infinity = f0(a++ + a, 23..toString()).next().value;

console.log(null, a, b, c, Infinity, NaN, undefined);

// uglified code
// (beautified)
var _calls_ = 10, a = 100, b = 10, c = 0;

async function* f0(e) {
    for (var t = a++, n = 5; 0 < --n; ) {}
    try {
        try {
            return void delete a;
        } catch (c) {} finally {
            e && "function" == typeof e.in && 0 <= --_calls_ && e.in(+("" + (0xdeadn << 16n | 0xbeefn)), "24", (c = 1 + c, 
            1 !== (c += 1, !1))), a++;
        }
    } catch (n) {
        for (var f = 5; a++ + e && 0 < --f; ) {
            for (var i = 5; (c = c + 1 + 1) + {
                async: (c = 1 + c, (!1 === (t && (t.next += -27))) % 0),
                let_2: e,
                value: (c = 1 + (c += 1), 2 == (t && (t.async >>= 4 ^ Infinity)) & !1),
                [(c = 1 + c, !1 ^ (t && (t.undefined = !1)))]: (c = 1 + c, NaN)
            } && 0 < --i; ) {}
        }
    }
    c += 1;
}

var Infinity = f0(a++ + a, "23").next().value;

console.log(null, a, b, c, Infinity, NaN, void 0);

export {
    f0
};

original result:
null 103 10 0 Infinity NaN undefined

uglified result:
null 102 10 0 Infinity NaN undefined

// reduced test case (output will differ)

// (beautified)
var a;

async function* f0() {
    (function c_1() {
        try {
            try {
                return delete a;
            } finally {
                a++;
            }
        } catch (yield) {}
        0();
    })();
}

f0().next();

console.log(a);
// output: NaN
// 
// minify: undefined
// 
// options: {
//   "compress": {
//     "passes": 1000000,
//     "sequences": 1000000,
//     "unsafe": true,
//     "unsafe_Function": true,
//     "unsafe_math": true,
//     "unsafe_proto": true,
//     "unsafe_regexp": true
//   },
//   "module": false,
//   "output": {
//     "v8": true
//   },
//   "validate": true
// }

minify(options):
{
  "compress": {
    "passes": 1000000,
    "sequences": 1000000,
    "unsafe": true,
    "unsafe_Function": true,
    "unsafe_math": true,
    "unsafe_proto": true,
    "unsafe_regexp": true
  },
  "module": false,
  "output": {
    "v8": true
  }
}

Suspicious compress options:
  dead_code
  inline
  passes
  unused

Suspicious options:
  rename