ufuzz failure

[alexlamsl]

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

async function* f0(foo_2_1, foo_2, b_1) {
    try {
        {
            b = a;
            if (foo_2_1) {
                return;
            } else {
                return;
            }
            c = c + 1;
        }
    } catch (arguments) {
        {
            var brake8 = 5;
            while (foo_2 && typeof foo_2.set == "function" && --_calls_ >= 0 && ((c = c + 1) + void (([] === {}) * (this & [ , 0 ][1]) << ("a" | this || 38..toString() ^ Infinity)), 
            foo_2.set)(a++ + [ --b + (foo_2 && typeof foo_2.length == "function" && --_calls_ >= 0 && foo_2.length()) ].var) && --brake8 > 0) {
                {
                    var brake10 = 5;
                    do {
                        {
                            var brake11 = 5;
                            L33030: while ((c = c + 1) + (typeof f2 == "function" && --_calls_ >= 0 && f2()) && --brake11 > 0) {
                                for (var brake12 = 5; (c = c + 1) + (typeof foo_2_1 == "function" && --_calls_ >= 0 && foo_2_1(..."" + arguments)) && brake12 > 0; --brake12) {
                                    for (var brake13 = 5; (c = 1 + c, (foo_2_1 && (foo_2_1[arguments && arguments.get] = (c = c + 1, 
                                    5) >> (1 & Infinity))) | -5 % 25 !== ("b" !== "undefined")) && brake13 > 0; --brake13) {
                                        c = 1 + c, delete (23..toString() == 4) >> (1 >>> "c" < 22 << -3);
                                    }
                                }
                            }
                        }
                    } while ((c = c + 1) + {
                        in: ((c = 1 + c, ("number" != "") % (22 | "") + (foo_2_1 = undefined > Infinity) * (-2 - "a")) || 2).toString()[c = 1 + c, 
                        (null || Infinity) && true === "undefined", c = c + 1, c = c + 1, 
                        this],
                        1.5: --b + ((c = 1 + c, c = c + 1, (b_1 && (b_1.static += "function" >= "c")) % ("object" > "bar")) || 4).toString()[c = 1 + c, 
                        (foo_2 += 0 % "object") != "bar" < /[a2][^e]+$/ & -5 < this >= (null <= "")]
                    }[a++ + -(true + /[a2][^e]+$/ >> (Infinity >>> 24..toString()) !== ("bar" > -2 != ([] ^ NaN))) ? a++ + ((c = 1 + c, 
                    (22 !== -1) > (25 || "foo") || (c = c + 1, "a") == /[a2][^e]+$/ >> "function") || 2).toString()[c = 1 + c, 
                    22 !== "c" == [] / -2 ^ (([ , 0 ].length === 2) <= "bar") % (2 >> -1)] : --b + (foo_2_1 && typeof foo_2_1.in == "function" && --_calls_ >= 0 && foo_2_1.in((c = 1 + c, 
                    (c = c + 1, 1 | []) >>> ("" > -5 !== "b" <= undefined))))] && --brake10 > 0);
                }
                switch ([ --b + (c = 1 + c, +(foo_2 && ([ foo_2[c = 1 + c, (+"" ^ ([ , 0 ].length === 2) + "number") - ((-5 ^ undefined) === (5 != "function"))] ] = [ NaN <= NaN ])) + ((this ^ 2) !== "c" - Infinity)), --b + (typeof foo_2_2 !== "object") ][b--]) {
                  case (2 - "function" & ("bar" || 2)) >> ([ , 0 ].length === 2 & "a") - ([] >> [ , 0 ][1]):
                    for (var brake16 = 5; b_1 && b_1.static && brake16 > 0; --brake16) {
                        c = 1 + c, (0 / 24..toString(), -2 != "bar") >= ((null, 
                        "a") < (1 | -4));
                    }
                    {
                        var expr18 = a++ + [ (c = 1 + c, 1 + "undefined" != (foo_2 && (foo_2[c = 1 + c, 
                        c = c + 1, "number" * ([ , 0 ].length === 2) / (foo_2 && (foo_2.static += "undefined" * 25))] = -4 <= ([ , 0 ].length === 2))) !== (c = c + 1, 
                        undefined) * (true >= -4)), (c = 1 + c, ((22 ^ -4) != (-2 & -3)) << ([ , 0 ][1] * 1 === (/[a2][^e]+$/ != -3))) ][c = 1 + c, 
                        ("bar" && "object") >> ~NaN != (c = c + 1, this > -0)];
                        for (b_1 in expr18) {
                            c = 1 + c;
                            var a_2 = expr18[b_1];
                            var bar;
                        }
                    }
                    {
                        return [ (c = 1 + c, arguments = (c = c + 1, true + -0) != ((foo_2 = (4, 
                        25)) && /[a2][^e]+$/ << "foo")), (c = 1 + c, (this < "foo") % (-5 / this) || 24..toString() >>> 0 >> (foo_2 >>= -4 == 2)), (c = 1 + c, 
                        ("c" < "foo") / ([ , 0 ][1] % [ , 0 ][1]) * ((-5 <= 38..toString()) * (c = c + 1, 
                        -0))), (c = 1 + c, foo_2 ^= (("foo" || 25) | "number" >> -2) + ((c = c + 1, 
                        null) >= (3 & ""))), (c = 1 + c, ("number" || []) / (24..toString() * "foo") | (25 | -1) / (-5 >> 22)) ].c;
                    }
                    break;

                  case foo_2_1:
                    break;

                  case a++ + ((c = c + 1) + -b || a || 3).toString():
                    {
                        var let_1 = function f1(arguments) {
                        }(38..toString(), (c = 1 + c, ((3 ^ "undefined") >> (-0 << "undefined")) - ((-5 === this) >>> (0 << {}))));
                    }
                    {
                        var brake22 = 5;
                        while ((c = c + 1) + [][c = 1 + c, (3 === 0 ^ -"foo") + (c = c + 1, 
                        "a") / (arguments && (arguments.value = "" >>> 38..toString()))] && --brake22 > 0) {
                        }
                    }
                    var NaN_2 = typeof f3 == "function" && --_calls_ >= 0 && f3((c = 1 + c, 
                    (-1 ^ -0) === (arguments && (arguments.async += true << "a")) ^ delete ("undefined" >= 2)), "c");
                    break;

                  case a++ + (b + 1 - .1 - .1 - .1):
                    {
                        var brake25 = 5;
                        do {
                            c = c + 1;
                        } while (a++ + typeof await_1 && --brake25 > 0);
                    }
                }
            }
        }
        L33031: {
            var Infinity = --b + (b += a), NaN = this in {
                value: true in [ (c = 1 + c, ((NaN += "a" | "bar") !== (c = c + 1, 
                "a")) <= "number" * -5 + (-2 ^ 24..toString())) ]
            };
            c = c + 1;
        }
    } finally {
        (c = c + 1) + (--b + foo_2_1 || a || 3).toString();
    }
}

var NaN = f0(false).next().done;

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

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

async function* f0(foo_2_1, foo_2, b_1) {
    try {
        return void (b = a);
    } catch (arguments) {
        for (var brake8 = 5; foo_2 && "function" == typeof foo_2.set && 0 <= --_calls_ && (c += 1, 
        "a" | this || 38..toString(), foo_2.set)(a++ + [ --b + (foo_2 && "function" == typeof foo_2.length && 0 <= --_calls_ && foo_2.length()) ].var) && 0 < --brake8; ) {
            var brake10 = 5;
            do {
                for (var brake11 = 5; (c += 1) + ("function" == typeof f2 && 0 <= --_calls_ && f2()) && 0 < --brake11; ) {
                    for (var brake12 = 5; (c += 1) + ("function" == typeof foo_2_1 && 0 <= --_calls_ && foo_2_1(..."" + arguments)) && 0 < brake12; --brake12) {
                        for (var brake13 = 5; c = 1 + c, !0 | (foo_2_1 && (foo_2_1[arguments && arguments.get] = (c += 1, 
                        5 >> (1 & Infinity)))) && 0 < brake13; --brake13) {
                            c = 1 + c, 23..toString();
                        }
                    }
                }
            } while ((c += 1) + {
                in: (c = 1 + c, (1 + (foo_2_1 = Infinity < void 0) * (0 / 0) || 2).toString()[c = (c = 1 + c) + 1 + 1, 
                this]),
                1.5: --b + (c = 1 + c, c += 1, ((b_1 && (b_1.static += !0)) % !0 || 4).toString()[c = 1 + c, 
                0 != (foo_2 += 0 / 0) & !0 <= (-5 < this)])
            }[a++ - (!0 + /[a2][^e]+$/ >> (Infinity >>> 24..toString()) !== (0 != ([] ^ NaN))) ? a++ + (c = 1 + c, 
            c += 1, 2..toString()[c = 1 + c, 1 == [] / -2 ^ ((2 === [ , 0 ].length) <= "bar") % 0]) : --b + (foo_2_1 && "function" == typeof foo_2_1.in && 0 <= --_calls_ && foo_2_1.in((c = 1 + c, 
            c += 1, (1 | []) >>> !0)))] && 0 < --brake10);
            switch ([ --b + (c = 1 + c, +(foo_2 && ([ foo_2[c = 1 + c, (0 ^ (2 === [ , 0 ].length) + "number") - !1] ] = [ NaN <= NaN ])) + ((2 ^ this) != "c" - Infinity)), --b + ("object" != typeof foo_2_2) ][b--]) {
              case 0 >> (2 === [ , 0 ].length & "a") - ([] >> 0):
                for (var brake16 = 5; b_1 && b_1.static && 0 < brake16; --brake16) {
                    c = 1 + c, 24..toString();
                }
                var expr18 = a++ + [ (c = 1 + c, "1undefined" != (foo_2 && (foo_2[c = 1 + c, 
                c += 1, "number" * (2 === [ , 0 ].length) / (foo_2 && (foo_2.static += 0 / 0))] = -4 <= (2 === [ , 0 ].length))) !== !0 * void (c += 1)), 1 ][c = 1 + (c = 1 + c), 
                "object" >> ~NaN != (c += 1, -0 < this)];
                for (b_1 in expr18) {
                    c = 1 + c;
                }
                return [ (c = 1 + c, arguments = 1 != (foo_2 = 25, 0)), (c = 1 + (c += 1), 
                (this < "foo") % (-5 / this) || 24..toString() >>> 0 >> (foo_2 >>= !1)), (c = 1 + c, 
                0 / 0 * ((-5 <= 38..toString()) * -0)), (c = 1 + (c += 1), foo_2 ^= 1), (c = 1 + (c += 1), 
                "number" / ("foo" * 24..toString()) | 1) ].c;

              case foo_2_1:
                break;

              case a++ + ((c += 1) + -b || a || 3).toString():
                38..toString(), c = 1 + c;
                for (var brake22 = 5; (c += 1) + [][c = 1 + c, 0 + (c += 1, "a" / (arguments && (arguments.value = "" >>> 38..toString())))] && 0 < --brake22; ) {}
                "function" == typeof f3 && 0 <= --_calls_ && f3((c = 1 + c, -1 === (arguments && (arguments.async += 1)) ^ !0), "c");
                break;

              case a++ + (b + 1 - .1 - .1 - .1):
                for (var brake25 = 5; c += 1, a++ + typeof await_1 && 0 < --brake25; ) {}
            }
        }
        var Infinity = --b + (b += a), NaN = this in {
            value: !0 in [ (c = 1 + c, ((NaN += 0) !== (c += 1, "a")) <= 0 / 0 + (-2 ^ 24..toString())) ]
        };
        c += 1;
    } finally {
        c += 1, (--b + foo_2_1 || a || 3).toString();
    }
}

var NaN = f0(!1).next().done;

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

export {
    _calls_,
    a,
    b,
    c
};

original result:
null 100 99 1 Infinity NaN undefined

uglified result:
null 100 100 0 Infinity NaN undefined

// reduced test case (output will differ)

// (beautified)
async function* f0(foo_2_1) {
    try {
        b = 0;
        if (foo_2_1) {
            return;
        } else {
            return;
        }
    } finally {
        --b;
    }
}

f0().next();

console.log(b);
// output: -1
// 
// minify: 0
// 
// options: {
//   "mangle": false,
//   "output": {
//     "v8": true
//   },
//   "validate": true
// }

minify(options):
{
  "mangle": false,
  "output": {
    "v8": true
  }
}

Suspicious compress options:
  conditionals