// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// VMOptions=--optimization_counter_threshold=1

import "package:expect/expect.dart";

// Found by DartFuzzing: would sometimes crash on OSR
// https://github.com/dart-lang/sdk/issues/38436

// Note: When this test was migrated to null safety, changed several type
// annotations to dynamic to fix the hundreds of null safe errors. That was a
// less invasive change than adding `?` and `!` throughout the test.
import 'dart:async';
import 'dart:cli';
import 'dart:collection';
import 'dart:convert';
import 'dart:core';
import 'dart:io';
import 'dart:isolate';
import 'dart:math';
import 'dart:typed_data';

dynamic var0 = '';
dynamic var1 = true;
int var2 = -30;
double var3 = 0.895077679110543;
dynamic var4 = '';
List<int> var5 = [55, -70];
Set<int> var6 = {
  1024,
  for (int loc0 in [
    79,
    ...[23],
    ...[90, -89, -24],
    -90,
    11,
    -19,
    -91
  ])
    -55,
  67,
  -80,
  for (int loc0 = 0; loc0 < 29; loc0++) 20,
  for (int loc0 = 0; loc0 < 24; loc0++) ...{23, -41},
  ...{
    -75,
    128,
    9223372034707292159,
    -56,
    -59,
    for (int loc0 in {
      -67,
      for (int loc1 in [-27, -59, 31, 32, -66, -87]) -9223372036854775680,
      85,
      -45,
      if (false) 70,
      13,
      43,
      48
    })
      if (true) 63,
    ...{-90, -24, -9223372036854743041, -9223372032559808383, 86},
    -25
  }
};
dynamic var7 = {
  6: '',
  ...{56: 'B\u2665pwO', 73: 'ZJDi\u{1f600}m'},
  ...{73: ')', 14: '93Q'},
  98: 'xA0jQL',
  21: ')\u2665TOy',
  for (int loc0 = 0; loc0 < 82; loc0++) 34: 'Q3\u2665#61',
  ...{70: 'XXRXl3O', 56: '\u2665lda2Zy', 38: 'Dr#mtz', 6: 'nx'},
  27: '('
};

Set<int> foo0() {
  var3 += ((((var0 + var7[var5[88]])).isEmpty ? true : var1)
      ? (var1 ? (var3 ?? var3) : var3)
      : (var1 ? 0.24414824314186978 : var3));
  var1 ??= true;
  return {(var2--), Duration.secondsPerHour, var5[var2]};
}

Map<int, String> foo1(List<int> par1, bool par2) {
  throw ((-(var3)) * (-(0.943305664017911)));
}

List<int> foo2(Set<int> par1, List<int> par2, dynamic par3) {
  switch (-49) {
    case 4149672951:
      {
        for (int loc0 in foo0()) {
          var6 = var6;
          try {
            for (int loc1 = 0; loc1 < 70; loc1++) {
              switch (((var1
                      ? ((var1 ? var1 : true) ? Float32x4.xzzw : (--var2))
                      : (4295032831 % (loc1 + 93))))
                  .floor()) {
                case 3294548737:
                  {
                    var5[Int32x4.xxwy] ^=
                        (loc0 * ('!').compareTo(((!(true)) ? var4 : 'S')));
                  }
                  break;
                case 3294548738:
                  {
                    var0 = var4;
                    loc0 <<= Int32x4.zwxz;
                  }
                  break;
              }
              {
                int loc2 = 0;
                do {
                  var1 = ('Ncb\u2665P9K').isEmpty;
                  var1 ??= (!(true));
                } while (++loc2 < 91);
              }
            }
            par3 ??= {
              44: ((false
                      ? false
                      : ((true
                              ? var7
                              : {
                                  17: par3[(var5[-73] - -20)],
                                  80: var7[
                                      ((++loc0) ~/ ((!(false)) ? 47 : var2))],
                                  30: '8Qvz3',
                                  36: '',
                                  10: (('@B!0bW6' + var4)).toLowerCase(),
                                  89: var7[-9223372036854775296],
                                  4: ') '
                                }) !=
                          var7))
                  ? ((var1 || (!(var1))) ? var7[Float32x4.wxzw] : var7[-7])
                  : '8h'),
              for (int loc1 in [
                (false
                    ? ((([
                                  var2,
                                  -39,
                                  -74,
                                  Float32x4.zzxy,
                                  (~(var5[(67 + -86)])),
                                  -53
                                ] +
                                [(var2++), var5[par2[(--loc0)]]]) !=
                            [
                              var5[var5[var5[(loc0++)]]],
                              loc0,
                              loc0,
                              -55,
                              -69,
                              loc0
                            ])
                        ? (loc0--)
                        : loc0)
                    : var2),
                (75 ^ 93),
                (false ? var5[Float32x4.xzyw] : (loc0++)),
                ...[
                  for (int loc2 in {
                    -22,
                    (loc0 ^ 2),
                    var5[(-((par2[-79] * 86)))],
                    (++loc0),
                    ((par2[var5[-45]] ?? 55) >> (true ? Int32x4.wyww : -45)),
                    (~((++var2))),
                    par2[var2]
                  })
                    (loc0--),
                  if ((var7[(false ? (-(loc0)) : 19)]).endsWith(var4))
                    (++var2)
                  else
                    (var1 ? loc0 : 39),
                  (((var2++) & var2) & -26),
                  if (false) (var1 ? Float32x4.wzzw : var5[129]),
                  for (int loc2 in {
                    (loc0--),
                    (true ? loc0 : loc0),
                    var2,
                    var5[(0.4452451921266031).floor()],
                    (~(-4294967196)),
                    (loc0--),
                    (--var2)
                  })
                    (var1 ? -30 : (loc0++)),
                  (~((var1 ? 51 : var2))),
                  (((var3 ?? pi) < 0.9098824013356337)
                      ? ((true ? 57 : -48) << (--var2))
                      : par2[-59])
                ]
              ])
                84: var4,
              57: var4
            };
          } catch (exception, stackTrace) {
            /**
             ** Multi-line
             ** documentation comment.
             */
            for (int loc1 = 0; loc1 < 89; loc1++) {
              switch ((var2--)) {
                case 3807258589:
                  {
                    print(({
                          (-34 ^
                              ((false || var1)
                                  ? 24
                                  : (-(((-((var1
                                          ? par2[(-(71))]
                                          : 9223372032559808768))) +
                                      (~(loc1))))))),
                          (~((true ? loc0 : (false ? -75 : 33)))),
                          Float32x4.zxwz,
                          (false ? (15 * -83) : (var2--)),
                          ((var7 !=
                                  ((true ? var1 : false)
                                      ? var7
                                      : {
                                          99: (true ? 'TobD' : var0),
                                          59: (var4 ?? var4),
                                          13: var4,
                                          58: Uri.encodeFull(var4),
                                          99: var7[loc1]
                                        }))
                              ? loc1
                              : (var1
                                  ? ((72 >> -15) ~/ (loc0--))
                                  : -9223372030412324864)),
                          32
                        } ??
                        par1));
                  }
                  break;
                case 3807258592:
                  {
                    var1 ??= true;
                    try {
                      var7 = {9: (var1 ? 'ON' : 'f\u{1f600}b')};
                      par2 = (true
                          ? var5
                          : [
                              DateTime.january,
                              (40 - (~(var2))),
                              (var1 ? (--loc0) : 23),
                              var5[(--var2)]
                            ]);
                    } catch (exception, stackTrace) {
                      var3 /= 0.9998663372091022;
                    } finally {
                      par2 ??= ((var1
                              ? false
                              : (((par1 ??
                                          {
                                            -68,
                                            86,
                                            -33,
                                            var5[(-9223372034707292159 - 90)],
                                            (24 - (++var2)),
                                            (-(var2)),
                                            (loc1 * Int32x4.wyxx)
                                          }))
                                      .difference({
                                    (var1 ? Float32x4.yzyw : (loc1 % loc0)),
                                    6,
                                    22,
                                    91,
                                    loc0,
                                    (true ? loc1 : loc1)
                                  }) ==
                                  foo0()))
                          ? par2
                          : [
                              (var2--),
                              (-((++loc0))),
                              ((-(var5[-52])) ~/
                                  (true ? Int32x4.wyyy : (loc0--))),
                              (var3).toInt()
                            ]);
                      var5[99] += (~(Float32x4.ywxw));
                    }
                  }
                  break;
              }
              var5 = (par2 ??
                  [
                    ...[72],
                    for (int loc2 in {Float32x4.xxwz, loc1})
                      ((loc0--) ~/ (var2++)),
                    par2[(++var2)],
                    (-((--var2))),
                    (var2++),
                    -56,
                    (~((~(loc0)))),
                    for (int loc2 in {
                      (-((~(17)))),
                      Float32x4.zzzw,
                      Float32x4.zyyz,
                      (var2--),
                      (Int32x4.wzwz % 78),
                      loc0
                    })
                      Int32x4.xzzy
                  ]);
            }
            {
              int loc1 = 0;
              do {
                loc0 &= (-(4295000065));
              } while (++loc1 < 94);
            }
          } finally {
            var3 -= 0.020483900923215503;
            try {
              return [
                ...[
                  (loc0--),
                  for (int loc1 in {Float32x4.yxyz})
                    if (var1) (~(-35)) else loc0,
                  (++loc0),
                  for (int loc1 = 0; loc1 < 43; loc1++)
                    (var5[var5[par2[var5[-9223372032559808384]]]] &
                        Int32x4.yzxy),
                  for (int loc1 = 0; loc1 < 98; loc1++) (-((~(Int32x4.xwwy)))),
                  Float32x4.yzzz
                ],
                (-(Int32x4.xzxz))
              ];
            } catch (exception, stackTrace) {
              for (int loc1
                  in (((((!((((0.13101852551635873 == 0.4825498460563603)
                                          ? var7
                                          : var7) !=
                                      var7)))
                                  ? 1
                                  : par2[var2]))
                              .isEven
                          ? {
                              (var2++),
                              (-48 | -54),
                              (~(par2[loc0])),
                              par2[var5[Int32x4.zyzz]],
                              -2,
                              (true ? (~((-(((!(false)) ? -11 : var2))))) : 73),
                              if ((0.15992181539430828).isInfinite) (++var2)
                            }
                          : (false ? {-6} : {((++loc0) % 27), 92})) ??
                      Set.identity())) {
                var6 ??= foo0();
              }
              var5[(~(((true ? -10 : Float32x4.zzwy) -
                  Duration.millisecondsPerSecond)))] = (~((var2--)));
            }
          }
        }
        par3.forEach((loc0, loc1) {
          // Single-line comment.
          var6 = (var6 ?? foo0());
          par1 = {
            if (('X2yPgV').endsWith('b'))
              Float32x4.yxxy
            else if (true)
              Int32x4.xzyw
            else
              for (int loc2 = 0; loc2 < 9; loc2++) (++loc0),
            (4294967551 ?? (-((loc0--)))),
            (-69 ~/
                ((!(false))
                    ? ((((par2[Int32x4.zwzw]).isEven
                                ? (var3).truncateToDouble()
                                : 0.14035347150303745))
                            .isInfinite
                        ? Int32x4.yzxx
                        : par2[loc0])
                    : (var2++))),
            ((loc0++) - ((++var2) >> (~(par2[(var2--)]))))
          };
        });
      }
      break;
    case 4149672955:
      {
        par2[((var2 ^ (~((--var2)))) | -98)] *= -62;
        {
          int loc0 = 0;
          do {
            var0 = par3[(var5[4294967808] >> Float32x4.wwyx)];
          } while (++loc0 < 46);
        }
      }
      break;
  }
  var1 ??= (!((var3).isNaN));
  return (var1
      ? par2
      : Uri.parseIPv6Address(
          (var1 ? '' : '26DgiI'), (ZLibOption.maxMemLevel % 65), 68));
}

class X0 {
  bool fld0_0 = true;
  Set<int> fld0_1 = {
    31,
    if (true) ...{
      -93,
      -4294967041,
      -4294934527,
      if (false) 92,
      if (true) 69
    } else
      85,
    ...{
      ...{73, 27},
      for (int loc0 in {
        for (int loc1 = 0; loc1 < 56; loc1++) -36,
        -23,
        -99,
        20,
        16,
        11,
        if (false) -24,
        if (true) 14
      })
        if (false) 69,
      -9223372032559808513,
      -9223372036854775553,
      -9223372036854774784,
      -22
    },
    81,
    ...{16, if (false) 67 else -30, if (true) 21 else -61, -84},
    -69
  };

  List<int> foo0_0(dynamic par1) {
    if ((var1 ? ((!(fld0_0)) ? true : false) : true)) {
      return ((var4).trim()).codeUnits;
    } else {
      for (int loc0 in var6) {
        fld0_0 ??= var1;
        for (int loc1 = 0; loc1 < 57; loc1++) {
          {
            Map<int, String> loc2 = Map.identity();
            par1 ??= Map.unmodifiable(Map.unmodifiable(Map.unmodifiable((true
                ? loc2
                : ((true
                        ? loc2
                        : foo1(
                            [var5[-60], loc0, var5[-48], -80, var5[var5[37]]],
                            var1)) ??
                    {
                      60: var0,
                      93: ((false ? var0 : '') + 'r\u{1f600}2B#p')
                    })))));
            var4 = ' ';
          }
          try {
            var5 = foo2(
                ({loc0, 37, Float32x4.wwyw} ?? var6),
                ((fld0_0
                        ? [
                            for (int loc2 = 0; loc2 < 1; loc2++)
                              (~(Float32x4.zyzz)),
                            (~((true
                                ? (Float32x4.yyzw >> (48 - (-((var2--)))))
                                : (~(loc0))))),
                            ((var4 ==
                                    String.fromEnvironment(
                                        (var1 ? 'l9FM' : par1[var5[loc0]])))
                                ? (++loc0)
                                : 4),
                            ...[
                              (~((var5[-9223372032559808448] - (++var2)))),
                              ...[
                                for (int loc2 in [
                                  ((-12 <= 55) ? 9223372032559841280 : loc0),
                                  var5[var5[(~(var5[var5[loc1]]))]],
                                  (var1 ? 67 : -74)
                                ])
                                  (var5[var2]).sign,
                                var5[-65],
                                if (fld0_0)
                                  var5[(var5[var5[-90]] ~/ 22)]
                                else
                                  (-9223372036854775679 + var5[16]),
                                76,
                                7
                              ],
                              (++var2),
                              -9223372034707292160,
                              (var2--),
                              var5[(var2--)]
                            ],
                            loc1,
                            Float32x4.ywxz,
                            ((++loc0) + (--loc0)),
                            for (int loc2 in [
                              for (int loc3 = 0; loc3 < 4; loc3++) loc1,
                              ...[
                                Float32x4.zxwy,
                                Float32x4.xzwx,
                                var2,
                                (++var2),
                                Int32x4.xzyy,
                                (var5[loc1] | (true ? -97 : -93)),
                                Float32x4.xwyz,
                                ((true || var1)
                                    ? (~((--loc0)))
                                    : (~((var5[18] % (-55 + loc0)))))
                              ],
                              (~((++loc0))),
                              -85,
                              (~((var2++))),
                              (true
                                  ? ZLibOption.maxMemLevel
                                  : var5[var5[var5[var5[var2]]]]),
                              ((true
                                      ? ((!((false
                                              ? (true ? fld0_0 : (!(false)))
                                              : fld0_0)))
                                          ? fld0_0
                                          : (({
                                                96: var4,
                                                60: '(0yBGn\u{1f600}',
                                                57: var4,
                                                73: var7[-43],
                                                38: var0
                                              }).isNotEmpty ||
                                              ({
                                                67: var4,
                                                14: 'M\u{1f600}1HNbP',
                                                6: 's',
                                                85: 'uyq',
                                                95: var7[(-(Int32x4.wwxw))],
                                                33: ''
                                              }).isNotEmpty))
                                      : false)
                                  ? var2
                                  : (++var2))
                            ]) ...[-27]
                          ]
                        : [
                            for (int loc2 = 0; loc2 < 87; loc2++)
                              (-47 * (~((((--var2) ^ loc0) ?? 78)))),
                            (-(((({
                                  14: (var3).toStringAsExponential(
                                      (false ? var5[-62] : 33)),
                                  16: '',
                                  71: var4,
                                  78: (([var5[(-(91))]] == var5) ? var4 : var0),
                                  9: par1[loc1],
                                  51: '-8ht',
                                  26: ('(2l3\u2665h' ?? var0),
                                  79: var4
                                }).isNotEmpty
                                    ? var5[(var2 % loc0)]
                                    : var2) %
                                ((!(NetworkInterface.listSupported))
                                    ? -22
                                    : ((var1
                                            ? ([
                                                  ZLibOption.STRATEGY_DEFAULT,
                                                  21,
                                                  loc1,
                                                  loc1,
                                                  loc0,
                                                  5,
                                                  loc0,
                                                  98
                                                ] ==
                                                Uri.parseIPv4Address(
                                                    var7[loc1]))
                                            : var1)
                                        ? (~((-20 %
                                            (var5).removeAt(Float32x4.wyxw))))
                                        : var5[var5[82]]))))),
                            (-(Float32x4.wwwz)),
                            Int32x4.wxxz,
                            ...[
                              (loc0++),
                              ...[
                                (--loc0),
                                -2,
                                ZLibOption.DEFAULT_WINDOW_BITS,
                                -42,
                                for (int loc2 = 0; loc2 < 2; loc2++) (-(-22)),
                                (~(-81))
                              ],
                              (--var2)
                            ],
                            (++var2),
                            ((!(false)) ? (--var2) : (((~(34)) >> 48) << 79)),
                            loc1
                          ]) +
                    foo2(
                        foo0(),
                        ([
                              (((~(var5[(-(var5[(87 % var5[(++var2)])]))])) ??
                                      -11) ~/
                                  (var2++)),
                              ((((!(var1)) && true) ? loc1 : 98) <<
                                  ((!((true != (var4 == par1[var5[(~(-83))]]))))
                                      ? -44
                                      : var5[88])),
                              Float32x4.yyyz,
                              -44,
                              Int32x4.xzyx,
                              (++loc0)
                            ] ??
                            [
                              ((foo1([((!(var1)) ? 24 : 81), -93], true))
                                      .isEmpty
                                  ? 52
                                  : (~(Int32x4.zyww))),
                              Int32x4.xxwz,
                              (-(-11)),
                              (loc0--),
                              ((!(bool.fromEnvironment('U\u2665')))
                                  ? (loc0++)
                                  : (++var2))
                            ]),
                        {
                          70: var7[7],
                          18: '\u2665(#&c\u{1f600}-',
                          58: 'KuNr',
                          96: '\u{1f600}2\u2665YY',
                          94: var0,
                          28: 'l-'
                        })),
                par1);
            {
              double loc2 = double.infinity;
              /*
               * Multi-line
               * comment.
               */
              return ('a!wNh!').codeUnits;
            }
          } catch (exception, stackTrace) {
            continue;
          } finally {
            fld0_0 = (!(fld0_0));
            var5 ??= ((Uri.parseIPv4Address('H') ??
                    (foo2({
                          loc1,
                          ([
                                if (((true ? loc0 : (loc0++)) <
                                    ((!(var1)) ? -90 : Int32x4.yyzx)))
                                  (~(var2))
                                else
                                  for (int loc2 in {
                                    if (SecurityContext.alpnSupported)
                                      var2
                                    else
                                      Int32x4.wzzy,
                                    -9223372036754112763,
                                    (-((var1
                                        ? var5[62]
                                        : (-(Float32x4.wzwz))))),
                                    (~(Float32x4.yxzy))
                                  })
                                    ((((true && (false ? fld0_0 : var1))
                                                ? fld0_0
                                                : false)
                                            ? true
                                            : (fld0_0 && var1))
                                        ? (true ? (~(loc1)) : var5[-16])
                                        : loc0),
                                for (int loc2 = 0; loc2 < 1; loc2++)
                                  ((false && var1) ? Float32x4.yzyy : 50)
                              ][var2] *
                              [
                                ...[
                                  (((-10 >> Int32x4.wxzw) *
                                          ((0.42979687169554437 >=
                                                  0.17848133910264385)
                                              ? -4
                                              : var5[-15])) |
                                      var5[(loc0++)]),
                                  ...[
                                    (('@jcNl\u2665P')
                                            .compareTo(var7[(loc0--)]) &
                                        (~((~(loc0))))),
                                    if ((!(((!(true)) && true)))) 2,
                                    loc1,
                                    ((var5[(loc0--)] | -38) & (loc0++)),
                                    var2,
                                    (~(-22)),
                                    if (false) loc0 else 80,
                                    (--loc0)
                                  ],
                                  ...[15],
                                  ((~((~(-5)))) ^ Int32x4.xxxz),
                                  79,
                                  for (int loc2 in [
                                    (fld0_0 ? -0 : (loc0++)),
                                    -49,
                                    for (int loc3 in [
                                      -16,
                                      (var2--),
                                      35,
                                      ((14 * -68) ~/ Int32x4.wwyy)
                                    ])
                                      var5[(fld0_0 ? 28 : (-41 ?? 19))],
                                    loc0,
                                    (var3).round(),
                                    if ((!((!((!(false))))))) loc1,
                                    (loc0++),
                                    Int32x4.wyww
                                  ])
                                    ((--var2) * var5[(6 & var5[(~(-53))])]),
                                  (loc0++),
                                  Float32x4.xwxx
                                ],
                                Int32x4.ywyw,
                                (-(ZLibOption.strategyFixed)),
                                (80 % (loc0--)),
                                var5[Int32x4.zxww]
                              ][var5[50]]),
                          (false ? -71 : 39),
                          (var5[-61]).toSigned(loc0),
                          -50,
                          4294967296
                        }, [
                          (16 *
                              (~(((var1 ? ZLibOption.STRATEGY_FIXED : -66) *
                                  4)))),
                          Float32x4.wwwx
                        ], {
                          63: var0,
                          52: (fld0_0 ? 'uG\u2665V@4' : '62'),
                          98: var7[var5[-83]],
                          70: (false
                              ? 'bSg'
                              : base64UrlEncode(([
                                    (~(var2)),
                                    -52,
                                    68,
                                    [
                                      10,
                                      loc1,
                                      92,
                                      53,
                                      Int32x4.zzyw,
                                      (true ? 12 : 19),
                                      (~(var5[(++var2)]))
                                    ][-64],
                                    (++loc0),
                                    (loc0 << -26)
                                  ] +
                                  [
                                    var5[(--loc0)],
                                    (((var1 ? var5[var5[(var2--)]] : loc1) +
                                            (--var2)) <<
                                        Int32x4.wyyx)
                                  ]))),
                          16: 'YsD\u2665\u2665K',
                          0: var0,
                          93: var7[(-(var5[-43]))]
                        }) ??
                        var5)) ??
                [
                  if (fld0_0) -90,
                  (--var2),
                  ...[
                    for (int loc2 in [
                      (false ? (~(-9)) : -4294901760),
                      (-(-7)),
                      -51,
                      (var1 ? -75 : [Float32x4.wwxw, Int32x4.zxyx][-7]),
                      Float32x4.xyww,
                      Int32x4.wwzx,
                      (loc0++),
                      (NetworkInterface.listSupported
                          ? [1000][Float32x4.zzyx]
                          : -71)
                    ])
                      -27,
                    Float32x4.wyzy,
                    (++var2)
                  ]
                ]);
          }
        }
      }
      throw Map.unmodifiable(foo1(
          (MapBase.mapToString(foo1((false ? [var2] : var5), false))).codeUnits,
          true));
    }
  }

  void run() {}
}

class X1 extends X0 {
  double fld1_0 = 0.47694301047645304;
  bool fld1_1 = true;

  Map<int, String> foo1_0(
      Map<int, String> par1, Map<int, String> par2, double par3) {
    // Single-line comment.
    for (int loc0 = 0; loc0 < 91; loc0++) {
      par2.forEach((loc1, loc2) {
        {
          bool loc3 = (fld1_1 || ('U\u2665').isEmpty);
          var3 /= 0.8504341352135224;
        }
      });
      {
        int loc1 = 66;
        while (--loc1 > 0) {
          if (((!((true || fld1_1))) == true)) {
            var0 ??= par2[var5[(~((false ? ((!(var1)) ? -95 : var2) : -37)))]];
            /**
             ** Multi-line
             ** documentation comment.
             */
            return Map.unmodifiable({
              55: var4,
              73: 'c#',
              17: (fld1_1
                  ? '7\u{1f600}e'
                  : ((!(var1)) ? '8E7AK2e' : 'Fm\u{1f600} F')),
              40: 'mb(\u{1f600}\u2665l',
              36: Uri.decodeFull((true ? par2[-32769] : var7[Float32x4.zyxz])),
              51: ((false &&
                      (((var1 ? true : true) || false)
                          ? (var7[(var2--)]).isEmpty
                          : true))
                  ? (fld1_1
                      ? (fld1_1 ? (var1).toString() : 'r9M')
                      : ((true ? (0.2863696758528199 != par3) : false)
                          ? (fld1_1 ? par1[Int32x4.zwyz] : var4)
                          : var4))
                  : var4),
              8: '6G',
              62: '+z@Gp'
            });
          } else {
            var5[Int32x4.zzyy] ??= (-(var5[((!(false)) ? loc1 : -34)]));
            {
              int loc2 = (-(7));
              var3 /= (true
                  ? (-(((-9223372032459145467).isEven
                      ? fld1_0
                      : (-((-(0.7008573255099826)))))))
                  : par3);
            }
          }
          for (int loc2 in foo2(var6, var5, {
            if (false) 11: par1[((var4).isEmpty ? 55 : -61)],
            12: 'f5j2v\u{1f600}',
            52: (((foo1(
                            (((var1
                                        ? {var5[-66], var2, 88, 12, 6, -96}
                                        : (var1
                                            ? {-25, 84, (var2--), var5[83]}
                                            : {-36, var5[51], var2})) !=
                                    {var5[(++var2)]})
                                ? [-2147483648, 46, loc0, var5[loc0], -21]
                                : foo2(
                                    {var5[var5[loc0]]},
                                    (true
                                        ? var5
                                        : [
                                            -30,
                                            var5[(-(-42))],
                                            var2,
                                            Float32x4.zywx,
                                            loc1,
                                            63,
                                            -25,
                                            -28
                                          ]),
                                    {30: 'j\u2665U', 98: var4})),
                            false))
                        .isNotEmpty
                    ? (false ? fld1_0 : 0.3202297128057393)
                    : 0.1301025669674245))
                .toStringAsFixed(((fld1_1 ? 79 : -88) + Int32x4.xyzw)),
            88: (false ? var7[(var2++)] : (var4 ?? '')),
            31: (var1
                ? (var1 ? par2[-87] : (true ? par2[-14] : var4))
                : ((fld1_1 != true) ? '3nd9t&' : var4)),
            22: ('(Czi' + '-Y')
          })) {
            var7[(loc2--)] = 's';
          }
        }
      }
    }
    return par1;
  }

  String foo1_1(int par1) => var0;
  Set<int> foo1_2(String par1) {
    for (int loc0 = 0; loc0 < 58; loc0++) {
      switch ((~(13))) {
        case 746492976:
          {
            switch (Duration.millisecondsPerDay) {
              case 3635015902:
                {
                  var7[var5[(var5[var2] * (-(var5[Float32x4.yxxz])))]] ??=
                      (var7[-79] + '(O@');
                  var7[loc0] ??= String.fromCharCode(var5[(true
                      ? (var5[((var1 ? true : (false ? fld1_1 : var1))
                              ? var5[Float32x4.wyyz]
                              : 73)] ~/
                          (-(84)))
                      : -15)]);
                }
                break;
              case 3635015905:
                {
                  var1 = (var1
                      ? (foo1_0(
                              (((!(false)) || fld1_1) ? var7 : var7),
                              foo1_0(
                                  {74: '\u2665e', 10: 'tw8jc0R'},
                                  foo1_0(
                                      var7,
                                      foo1_0(
                                          ({
                                                17: var7[Int32x4.zyxy],
                                                82: var7[64],
                                                27: 'VEtj',
                                                90: Uri.encodeQueryComponent(
                                                    foo1_1(var2)),
                                                68: 'wew0\u{1f600}'
                                              } ??
                                              foo1_0(var7, var7, var3)),
                                          ({
                                                65: 'mBeBfUj',
                                                81: var4,
                                                35: (var7[-43] + 'l'),
                                                68: var4
                                              } ??
                                              {
                                                33: ('N\u{1f600}xaY+' ?? par1),
                                                44: var7[var5[var2]],
                                                83: var4,
                                                86: 'k'
                                              }),
                                          asin(0.4245871535895427)),
                                      (-(0.2913717674787144))),
                                  0.9439800024935644),
                              (-((true
                                  ? ((var1 ? false : var1)
                                      ? 0.09441225978923817
                                      : 0.42622157485045953)
                                  : (-(0.29370792038584836)))))))
                          .isNotEmpty
                      : (false && true));
                  var3 += (-(fld1_0));
                }
                break;
            }
          }
          break;
        case 746492979:
          {
            var4 = var0;
            for (int loc1 = 0; loc1 < 88; loc1++) {
              var2 += 32;
            }
          }
          break;
      }
    }
    {
      int loc0 = 0;
      do {
        return foo0();
      } while (++loc0 < 57);
    }
    return foo0();
  }

  String foo1_3() {
    if ((0.42144855521066793).isNegative) {
      print((false ? (-(fld1_0)) : (-((-((-(0.26854952952179667))))))));
      switch (30) {
        case 3830102525:
          {
            try {
              var7.forEach((loc0, loc1) {
                var1 = (!(true));
                var6 = (foo1_2(var7[99]) ?? var6);
              });
              var6 ??= var6;
            } catch (exception, stackTrace) {
              var4 ??= ListBase.listToString([
                (Duration.microsecondsPerSecond + -82),
                (true
                    ? var5[(var2 ~/ (false ? (~((var1 ? 46 : var2))) : var2))]
                    : (-9223372034707292161 >> var5[var5[-86]])),
                Float32x4.wxyx
              ]);
            } finally {
              /**
               ** Multi-line
               ** documentation comment.
               */
              fld1_1 = (var5[var5[var2]]).isOdd;
            }
            /*
           * Multi-line
           * comment.
           */
            if ((SetBase.setToString((fld1_1
                    ? {12, (fld1_1 ? (-(-22)) : (-(4395630341)))}
                    : var6)))
                .isNotEmpty) {
              try {
                {
                  int loc0 = 86;
                  while (--loc0 > 0) {
                    {
                      int loc1 = 0;
                      do {
                        var0 = var7[(-(((--var2) &
                            ((var1 ? (fld1_0).isNaN : true)
                                ? (-16 | -20)
                                : ((0.7513819161190503).isNaN ? 45 : loc1)))))];

                        /// Single-line documentation comment.
                        var5[(true ? loc0 : Float32x4.zxzx)] %= loc0;
                      } while (++loc1 < 17);
                    }
                    for (int loc1 = 0; loc1 < 25; loc1++) {
                      var5[Float32x4.zywy] <<= Int32x4.ywwx;
                    }
                  }
                }
              } catch (exception, stackTrace) {
                var7 = Map.from(foo1_0({
                  81: (foo1_1(((++var2) * (-(var5[21])))) +
                      (var7[8] + (var7[var5[53]] ?? var0))),
                  for (int loc0 in [
                    (true ? 58 : Float32x4.wyww),
                    var5[(fld1_1 ? 46 : var2)]
                  ])
                    63: var7[(false
                        ? var5[((24 >> -9223372036854710272) & var2)]
                        : var5[(80 << var5[-31])])],
                  67: var0,
                  1: '3mlOA',
                  30: ('OQbG').substring((var2--), (--var2)),
                  93: ((var7[74] ?? var7[(++var2)])).toLowerCase(),
                  ...{
                    85: foo1_1(-21),
                    if ((!((!(false))))) 86: var0,
                    49: '62+v',
                    59: foo1_1((--var2)),
                    for (int loc0 in [
                      -10,
                      -65,
                      (var2++),
                      (var2++),
                      ((({
                                    ((var7[60] == var7[-30])
                                        ? var5[(-((var2++)))]
                                        : (var2--))
                                  } ==
                                  {var5[var2], -40, -81, (var2++), 93, 26})
                              ? 38
                              : (var1 ? var5[97] : -82)) *
                          (--var2)),
                      (~((true ? 5 : Float32x4.yxyy))),
                      (var2++),
                      ((++var2) << ((var2 % Int32x4.yxxw) >> (++var2)))
                    ])
                      54: (var0 + 'ANyqN'),
                    94: (var1 ? '0T\u2665#w' : (var0).toUpperCase()),
                    68: '@n',
                    67: base64UrlEncode(((0.07857744084458451).isInfinite
                        ? ([
                              var2,
                              var5[70],
                              -32,
                              Float32x4.yxwz,
                              31,
                              (~(var2)),
                              (var2 ?? (-70 + 57)),
                              -91
                            ] +
                            [
                              var2,
                              var5[((!(var1))
                                  ? var5[(var2 ~/ Float32x4.zwyw)]
                                  : var5[var5[(var5[(~(var2))] % var2)]])],
                              (var2 | (false ? (-(var2)) : var5[80])),
                              (var2--),
                              DateTime.daysPerWeek,
                              (var2 ~/ var2)
                            ])
                        : (var1 ? var5 : [(var2++)])))
                  },
                  if (false)
                    if (false)
                      26: (Uri.encodeComponent(foo1_1(var2)) + var7[var5[var2]])
                    else ...{
                      4: (double.negativeInfinity).toStringAsFixed(var2),
                      46: Uri.decodeQueryComponent('bst3jz'),
                      5: ((true
                              ? (true ? '(-f' : var7[(-(Int32x4.yzxz))])
                              : var7[(var5[(fld1_1 ? (var2--) : var2)] >>
                                  (-((false ? 8589934591 : 33))))]) ??
                          '4ov'),
                      37: var7[var5[100663045]],
                      13: '2B'
                    }
                }, {
                  71: 'Hxbq',
                  22: ('\u{1f600}Jtj').substring(
                      (-36 | var5[(~((var2++)))]), 9223372032559874048)
                }, 0.3710694748818374));
                fld1_0 ??= 0.010604823956237519;
              } finally {
                for (int loc0 = 0; loc0 < 84; loc0++) {
                  var5[Float32x4.xwwz] <<=
                      ((((fld1_1 ? false : ('e\u{1f600}O+Vc').isNotEmpty) &&
                                  (!(fld1_1)))
                              ? (-73 | var5[Int32x4.yzwx])
                              : Uint16List.bytesPerElement) ~/
                          var2);
                }
              }
            }
          }
          break;
        case 3830102528:
          {
            fld1_1 ??= true;
            throw (-((-17).ceilToDouble()));
          }
          break;
      }
    }
    return var0;
  }

  void run() {
    super.run();
    {
      int loc0 = 61;
      while (--loc0 > 0) {
        {
          int loc1 = 77;
          while (--loc1 > 0) {
            {
              int loc2 = 0;
              do {
                break;
              } while (++loc2 < 84);
            }
          }
        }
        if (((var1 || fld1_1) && (!((!((!((!((!(true)))))))))))) {
          switch (Int32x4.yyzx) {
            case 900727295:
              {
                /// Single-line documentation comment.
                fld1_1 ??= (!(true));
                for (int loc1 in ((var5 ??
                        Uri.parseIPv6Address(
                            foo1_3(), var5[(loc0 + var5[4096])], -34)) ??
                    var5)) {
                  var7[(38 << (false ? (~(-58)) : Float32x4.yyxy))] =
                      Uri.decodeFull(foo1_3());
                  var5 ??= var5;
                }
              }
              break;
            case 900727304:
              {
                fld1_1 =
                    (SecurityContext.alpnSupported ? (var3).isFinite : var1);
                fld1_0 += 0.3154406798513474;
              }
              break;
          }
          var2 ^= var2;
        } else {
          if (((-(var3)) <= (-(fld1_0)))) {
            var6 = foo1_2('0vsDWF9');
          } else {
            var6 ??= ((fld1_0 <= 0.16230005903410238)
                ? ((!((0.5144029832155854 > (0.8199455895430549 / var3))))
                    ? foo1_2('ken')
                    : var6)
                : (fld1_1 ? {56, 6442450945, 2} : {34}));
          }
          var5[Float32x4.zwzw] += (true ? var2 : (~(Float32x4.wyyx)));
        }
      }
    }
  }
}

class X2 extends X0 with X1 {
  dynamic fld2_0 = {for (int loc0 = 0; loc0 < 60; loc0++) -56, 29};

  bool foo2_0(int par1) => var1;
  bool foo2_1(bool par1) {
    for (int loc0 in var6) {
      var2 ~/= ((((((fld2_0 ?? (true ? var6 : var6)) ?? fld2_0))
                      .union({(~(-21)), 10}) !=
                  {(var5[90] ~/ (-(-90)))})
              ? par1
              : (var7[(~(82))]).isNotEmpty)
          ? ((~(loc0)) *
              ((true ? (-4294966272 ?? -21) : var2) +
                  Duration.millisecondsPerMinute))
          : (-9223372032559807488 ~/ 4294968296));
    }
    if (('DeAm#f' ==
        ((Uri.encodeQueryComponent((0.3687340601979223).toString()) ??
                var7[-23]) ??
            foo1_3()))) {
      throw (([Float32x4.wyyz, -9223372036854743039])
              .sublist((--var2), (--var2)) +
          ((true ? var1 : (!(false)))
              ? foo2(
                  foo1_2('JLXt'),
                  [
                    var5[Int32x4.zxzx],
                    Int32x4.xxwy,
                    (var2++),
                    Float32x4.yzxx,
                    (var2++),
                    -15
                  ],
                  foo1_0(var7, var7, 0.7904389283184639))
              : (var1
                  ? [Float32x4.yzyz, Int32x4.wxxy, var2, (~(var5[-47]))]
                  : var5)));
    } else {
      var7[var2] ??= ((({
            ...{
              for (int loc0 = 0; loc0 < 19; loc0++)
                36: (var7[var2] ?? (par1 ? ('ccb9z' + 'iM') : var0)),
              3: ('1sG' + var0),
              for (int loc0 in {
                (-(var5[var2])),
                if (var1) Int32x4.zxxx,
                -4294967168,
                -61,
                (~((par1 ? (~(-70)) : (var2--)))),
                (-(7)),
                -96,
                Uint32List.bytesPerElement
              })
                85: var4
            },
            if (foo2_0(-91)) 38: (var3).toString() else 30: 'uI\u2665\u{1f600}',
            72: '@'
          }[(par1 ? 14 : var2)])
                  .trim())
              .substring((36 ~/ var5[(++var2)]), var5[((-(25)) * -53)]) ??
          foo1_3());
      /*
       * Multi-line
       * comment.
       */
      {
        int loc0 = 0;
        do {
          {
            String loc1 = 'jG7t';
            /**
             ** Multi-line
             ** documentation comment.
             */
            {
              int loc2 = 57;
              while (--loc2 > 0) {
                print((var6 ??
                    (foo1_2(var0)).union(foo1_2(('n' + var7[(++var2)])))));
              }
            }
          }
        } while (++loc0 < 69);
      }
    }
    return (!(((!((par1 && false)))
        ? (true && foo2_0(-9223372036854771712))
        : (!(par1)))));
  }

  double foo2_2(Map<int, String> par1, int par2) {
    switch (var2) {
      case 3816231196:
        {
          throw (-(Int32x4.xxwx));
        }
        break;
      case 3816231204:
        {
          var7.forEach((loc0, loc1) {
            switch ((-43 ^ (-(Float32x4.wwxx)))) {
              case 2839002105:
                {
                  var0 ??= (SetBase.setToString(((var1 ? var1 : (true || var1))
                          ? fld2_0
                          : {
                              Int32x4.yyzw,
                              Int32x4.yyxy,
                              (2 >> Int32x4.ywzx),
                              (var1
                                  ? ((foo2_1(var1) ? 17 : loc0) ~/
                                      (-(var5[var2])))
                                  : par2),
                              Float32x4.zwwx,
                              par2,
                              Int32x4.wzzz,
                              Int32x4.zyzw
                            })) ??
                      (loc1 +
                          var7[((true
                                  ? (var1 &&
                                      bool.fromEnvironment(var7[(var2--)]))
                                  : foo2_1(false))
                              ? 35
                              : (-(66)))]));
                  for (int loc2 = 0; loc2 < 23; loc2++) {
                    switch ((-73 ^ (Int32x4.xyzz >> Float32x4.yzzz))) {
                      case 1710454916:
                        {
                          var3 = 0.3372913861348876;
                          print(((-(var3)) * var3));
                        }
                        break;
                      case 1710454922:
                        {
                          var4 ??= ((false
                                  ? (var1
                                      ? var1
                                      : (fld2_0 ==
                                          {
                                            (false ? -27 : (-(92))),
                                            loc2,
                                            var5[loc2],
                                            (var1
                                                ? Float32x4.yywy
                                                : (false ? -74 : 2)),
                                            ((-(-50)) ^ 32),
                                            (var2++)
                                          }))
                                  : var1)
                              ? base64UrlEncode([
                                  for (int loc3 in {
                                    (-(par2)),
                                    loc0,
                                    (-((par2++))),
                                    Float32x4.yyyx
                                  })
                                    (par2--),
                                  (-((-(var5[var5[var5[-41]]])))),
                                  if (({
                                        loc2,
                                        Duration.microsecondsPerSecond,
                                        (([
                                                  (par2++),
                                                  (-90 ^ -5),
                                                  var5[(~(0))],
                                                  loc2
                                                ] !=
                                                var5)
                                            ? -9223372032559808512
                                            : (par2++))
                                      } ==
                                      {
                                        (var1 ? (-((loc2 % loc2))) : loc2),
                                        -94,
                                        -62
                                      }))
                                    (++var2),
                                  loc2,
                                  for (int loc3 in {
                                    55,
                                    (~(var5[var5[(++par2)]])),
                                    ((var1
                                            ? (-((++var2)))
                                            : var5[(true ? var5[68] : 10)]) -
                                        par2),
                                    (-(Float32x4.wzxx))
                                  })
                                    (Int32x4.yxzy | var5[-1]),
                                  (foo2_1(false) ? (-(32)) : loc0),
                                  (--par2),
                                  if ((!(false))) (var1 ? var5[loc0] : 30)
                                ])
                              : ('b1TKp3' ??
                                  (var4 +
                                      var7[(~(var5[
                                          ((var1 ? var2 : loc2) - 72)]))])));
                        }
                        break;
                    }
                    fld2_0 = ((!((false
                            ? false
                            : (false ? (!((var7[-28] != ''))) : var1))))
                        ? (((var1
                                    ? (true ? Set.identity() : var6)
                                    : {
                                        -63,
                                        Int32x4.xxyx,
                                        var5[((var1
                                                ? (var5[-9223372032559808496] >>
                                                    59)
                                                : Int32x4.wxxy) ~/
                                            var5[var5[-48]])],
                                        (par2 ?? par2),
                                        44,
                                        var5[(var1 ? -26 : (-(par2)))]
                                      }) ??
                                ({
                                      loc2,
                                      var2,
                                      ZLibOption.defaultMemLevel,
                                      (true ? Int32x4.wyzz : 40),
                                      (false ? loc2 : var5[42]),
                                      -16
                                    } ??
                                    var6)))
                            .union({loc0, (var2++), (-1 * (~(var2)))})
                        : (bool.fromEnvironment((var3)
                                .toStringAsFixed(Uint64List.bytesPerElement))
                            ? fld2_0
                            : {
                                (par2++),
                                (var1 ? loc2 : (++var2)),
                                ((false || false) ? Int32x4.xyyz : (++par2)),
                                var5[-98],
                                Float32x4.zwwy,
                                var5[var5[62]],
                                (~(Float32x4.ywww))
                              }));
                  }
                }
                break;
              case 2839002106:
                {
                  for (int loc2 = 0; loc2 < 13; loc2++) {
                    {
                      int loc3 = 0;
                      do {
                        switch ((loc3 | -76)) {
                          case 2164097105:
                            {
                              var4 ??= (var1).toString();
                              var5 = ((!(((true || var1) !=
                                      (false ? var1 : (!(foo2_1(var1)))))))
                                  ? foo2(
                                      ((var6).union(foo1_2(loc1))).toSet(),
                                      [
                                        -67,
                                        if (((var1
                                                ? 59
                                                : (-((false ? -97 : par2)))) !=
                                            (false
                                                ? ((var1 || var1)
                                                    ? (-((par2++)))
                                                    : 4)
                                                : (--var2)))) ...[
                                          ((92 ~/ Int32x4.yzwx) << 70),
                                          Float32x4.xxyz,
                                          Int8List.bytesPerElement
                                        ] else
                                          69
                                      ],
                                      var7)
                                  : foo2(foo0(), Uri.parseIPv4Address(var0),
                                      var7));
                            }
                            break;
                          case 2164097111:
                            {
                              var4 ??= var7[Float32x4.zxzw];
                            }
                            break;
                        }
                      } while (++loc3 < 96);
                    }
                    fld2_0 = var6;
                  }
                }
                break;
            }
          });
          for (int loc0 in (foo2_1((var5 !=
                  (false
                      ? [par2]
                      : foo2(
                          var6,
                          [20],
                          ({
                                21: var0,
                                68: foo1_3(),
                                24: ('1MF' + '8s\u2665yx+ ')
                              } ??
                              {
                                9: var7[var2],
                                48: 'mB(wW\u{1f600}',
                                74: 'ojEw\u{1f600}\u{1f600}',
                                80: '\u26655E-hj\u{1f600}',
                                10: (false ? 'W7i5\u2665YX' : '! Ed9&'),
                                88: (false ? var0 : 'N0D9(H\u{1f600}'),
                                5: 'QZ'
                              })))))
              ? foo1_2('XP')
              : {
                  if ((foo2_1(var1)
                      ? (foo2_1((fld2_0).add(-9223372036854774784)) || var1)
                      : var1))
                    (~(Float32x4.zyww)),
                  Float32x4.xwyw,
                  ((((var1 ? true : var1) ? 0.3447071353935154 : var3) >=
                          0.5995056331958718)
                      ? ZLibOption.MAX_LEVEL
                      : 16),
                  9223372032559841279,
                  Int32x4.zwyy
                })) {
            for (int loc1 = 0; loc1 < 19; loc1++) {
              var1 = (!(bool.fromEnvironment(MapBase.mapToString({
                1: '4',
                56: var0,
                85: var0,
                51: var7[-4],
                42: ((!((!(false)))) ? par1[72] : MapBase.mapToString(var7))
              }))));
            }
          }
        }
        break;
    }
    print((((var1 ? 'kP' : (var1 ? 'irjF' : var7[var5[90]])) ??
            ((!(false)) ? 'vWa\u{1f600}' : var0)) +
        'xzpK'));
    return var3;
  }

  void run() {
    super.run();
    {
      int loc0 = (~(-24));
      var0 ??= ((false
              ? foo2_1((true
                  ? (var1 && (var2).isOdd)
                  : (('dTYR' ?? 'G\u{1f600}P14\u{1f600}a')).isEmpty))
              : ((var1 && true) || (!(var1))))
          ? (var4 ?? 'I')
          : 'QO');
    }
  }
}

class X3 extends X1 {
  dynamic fld3_0 = {
    if (true)
      if (false) 45: 'ynEn\u2665nG' else 70: 'c\u{1f600}mN4\u2665a',
    if (true) 30: '6\u2665P!Pbi',
    81: 't',
    82: '17fx#!',
    92: 'H',
    if (true) 69: ')Ls'
  };
  Set<int> fld3_1 = {27};
  int fld3_2 = 34;

  String foo1_1(int par1) {
    throw (ListBase.listToString(foo2({
          -4294967169,
          par1
        }, [
          -97,
          (var5[(var1 ? var5[87] : Int32x4.yxxy)] * Int32x4.yyxx),
          var2,
          (false ? 10 : var5[var5[(par1++)]])
        ], var7)) ??
        'o');
  }

  bool foo3_0(double par1) {
    {
      Set<int> loc0 = (true ? fld3_1 : var6);
      {
        Set<int> loc1 = (false
            ? foo0()
            : {
                for (int loc2 in [var2, (-(Float32x4.xzzw))])
                  if (false) Float32x4.wxyz else (++fld3_2),
                ((var1
                        ? 5
                        : var5[(((var5[(true ? fld3_2 : fld3_2)] ~/ 48) | 56) %
                            var5[-4])]) ??
                    (var2++))
              });
        for (int loc2 = 0; loc2 < 90; loc2++) {
          {
            int loc3 = 95;
            while (--loc3 > 0) {
              return (((0.7073184699576396).isNaN
                      ? var7
                      : (Map.of(Map.from(var7)) ??
                          Map.unmodifiable(Map.identity()))))
                  .isEmpty;
            }
          }
          try {
            var1 = (((12 >= Int32x4.ywxx) ? true : true)
                ? false
                : (((var1 ? fld3_0[Int32x4.wyxy] : '') ?? var7[Float32x4.xwwx]))
                    .isEmpty);
            var2 |= ((fld3_2++) ?? (fld3_2--));
          } catch (exception, stackTrace) {
            var5 ??= var5;
          } finally {
            var4 = 'A';
            break;
          }
        }
        {
          double loc2 = (-(exp((acos(0.06129144867031855) ?? var3))));
          fld3_0 = (((({Int32x4.ywxw, 6442450943}).union(foo0()))
                      .add((++fld3_2))
                  ? false
                  : false)
              ? foo1_0(
                  (foo1([var5[var2], var5[75], 42], false) ?? var7), var7, loc2)
              : (var1
                  ? {
                      for (int loc3 = 0; loc3 < 48; loc3++) 78: 'dWek8',
                      40: fld3_0[(var5[-81] & Int32x4.xzyw)],
                      73: (' )G\u2665-d(').substring(
                          (NetworkInterface.listSupported
                              ? (~(((++var2) ?? (fld3_2 * fld3_2))))
                              : var5[-75]),
                          fld3_2),
                      74: ('k9O\u2665').trimLeft(),
                      88: var7[(++var2)],
                      for (int loc3 = 0; loc3 < 27; loc3++)
                        60: ((false || var1) ? var7[46] : var0),
                      99: ((var3).isNaN
                          ? (Uri.decodeComponent(foo1_3()) + var4)
                          : var7[-77]),
                      92: (true
                          ? ('').padLeft(82, '')
                          : ('' ?? var7[(false ? 94 : 58)]))
                    }
                  : var7));

          /// Single-line documentation comment.
          fld3_1 ??= ((loc1 ?? foo1_2(fld3_0[(var2--)])) ?? foo1_2(foo1_3()));
        }
      }
    }
    return (var1 ? (!(var1)) : var1);
  }

  String foo3_1(int par1, String par2, String par3) {
    switch (var2) {
      case 3768780679:
        {
          {
            int loc0 = (++par1);
            var0 ??= ListBase.listToString(var5);
            if (true) {
              var5 = [
                Float32x4.xyxz,
                (var1
                    ? ((!(false)) ? Float32x4.xyyw : (++fld3_2))
                    : var5[fld3_2]),
                par1,
                (~(Float32x4.zxwy)),
                if ((foo3_0(var3)
                    ? ([
                          (++fld3_2),
                          ...[
                            ...[
                              var5[(true ? Float32x4.xxzx : (--fld3_2))],
                              54,
                              (-((((foo3_0(var3)
                                          ? (!(false))
                                          : ((var1 ? (~(-63)) : var5[-40]))
                                              .isOdd)
                                      ? ((0.8329420640871532 != var3) && var1)
                                      : var1)
                                  ? 43
                                  : (Float32x4.zxxy - Float32x4.zxxw)))),
                              Int32x4.zzwx
                            ],
                            ...[
                              (var5[-48] * (fld3_2++)),
                              Int32x4.wyyw,
                              (~(-76)),
                              ((par1).isEven ? (--par1) : -13),
                              Float32x4.wxyx
                            ],
                            for (int loc1 in [
                              (++fld3_2),
                              -15,
                              (SecurityContext.alpnSupported
                                  ? Int32x4.yxyw
                                  : Float32x4.yxxw),
                              if (true) var5[(var1 ? -32768 : par1)],
                              ((--var2) ^ (++fld3_2))
                            ])
                              (fld3_2--),
                            93,
                            (~((-(ZLibOption.minMemLevel)))),
                            ((Float32x4.zyzx >> -14) & Float32x4.yxxw)
                          ],
                          (var1
                              ? (++par1)
                              : ((var3).isInfinite ? Float32x4.zwww : -84)),
                          var2
                        ] ==
                        [
                          9223372032559808639,
                          -85,
                          Float32x4.wzyy,
                          loc0,
                          [
                            ((-(36)) <<
                                ((var1
                                        ? var1
                                        : ({
                                            45: 'ay',
                                            7: par3,
                                            69: Uri.decodeFull(
                                                (foo1_3() + 'LX+'))
                                          }).isEmpty)
                                    ? (~((13 | 64)))
                                    : (-(var2)))),
                            (par1--),
                            ((~((true ? (var2--) : -31))) >> 9),
                            (-((35 % (~(var5[var5[39]]))))),
                            4395630341,
                            Int32x4.zxxy,
                            if ((var1
                                ? foo3_0(var3)
                                : (0.6201792653929837).isInfinite)) ...[
                              Int32x4.wxxx,
                              (fld3_2 * (--fld3_2)),
                              var5[((~(var5[var5[var5[(-(-23))]]])) +
                                  (~(-4294966296)))],
                              loc0,
                              for (int loc1 in [var5[Float32x4.yzww]]) 17,
                              (~(var5[(++par1)])),
                              -58,
                              ((!(('').isEmpty))
                                  ? ((-(Float32x4.ywwx)) * (++par1))
                                  : Int32x4.yxyz)
                            ]
                          ][((var1 ? var1 : var1) ? var5[0] : par1)],
                          ((~(70)) +
                              (par1 + (-77 | ZLibOption.MAX_WINDOW_BITS))),
                          (-(Int32x4.zywy)),
                          (~(Float32x4.zywz))
                        ])
                    : (var1 ? true : true)))
                  fld3_2
              ];
            }
          }
          var3 *= ((var3 + 0.6761038672016147) ?? (-(double.minPositive)));
        }
        break;
      case 3768780685:
        {
          {
            int loc0 = 67;
            while (--loc0 > 0) {
              {
                Map<int, String> loc1 = foo1(
                    Uri.parseIPv4Address(('E Hu\u{1f600}' + '\u2665l&#!')),
                    (!(false)));
                var3 ??= var3;
              }
              var5 = (var5 +
                  ((({
                    79: (foo1_3() ?? 'eD'),
                    73: (var1 ? par2 : ' xdXgW'),
                    4: 'pUc(q',
                    15: 'K\u{1f600}hmdZ\u2665',
                    95: (var1 ? var4 : (var1 ? fld3_0[-45] : foo1_3()))
                  }).isNotEmpty
                          ? ((var1 ? var1 : (var1 ? var1 : foo3_0(var3))) ||
                              foo3_0(var3))
                          : (!(((false || true) ? var1 : false))))
                      ? [
                          (~((-61 ??
                              (~((-(var5[(var1 ? fld3_2 : var5[34])]))))))),
                          (var5[13] ^ (var1 ? 35 : -76)),
                          (-(((~(-47)) ~/ (--par1))))
                        ]
                      : foo2({
                          -36,
                          ((0.3910802543332075).isNegative
                              ? (~((var2++)))
                              : (var2 &
                                  (var1
                                      ? [
                                          -67,
                                          (fld3_2++),
                                          if ((!((!((var1
                                              ? true
                                              : (!(false))))))))
                                            (false
                                                ? (~(Float32x4.wyyy))
                                                : (var1
                                                    ? (1 ^ (-(16)))
                                                    : var5[94])),
                                          fld3_2,
                                          var2,
                                          67
                                        ][-12]
                                      : Float32x4.wwxw))),
                          26,
                          [
                            (var1
                                ? (--fld3_2)
                                : (((!(var1))
                                        ? (~((foo3_0(0.9959805940480148)
                                            ? (33 ~/ loc0)
                                            : Float32x4.xywx)))
                                        : (15 % var5[var5[-47]])) <<
                                    -86)),
                            (-((~(RawSocketOption.levelIPv6))))
                          ][var5[var5[(ZLibOption.maxMemLevel ^ -3)]]],
                          -29
                        }, [
                          (var1 ? Float32x4.wxxw : (--par1)),
                          ...[
                            52,
                            (-((true ? -12 : 44))),
                            var5[((var5[34] * 30) >> 4294967360)],
                            ((--var2) <<
                                (true
                                    ? var5[(-4 ~/ Int32x4.yyww)]
                                    : (bool.fromEnvironment(var7[fld3_2])
                                        ? (~((false ? loc0 : var5[(++par1)])))
                                        : ((!(false))
                                            ? (var5[var5[loc0]] ^ Int32x4.wxzz)
                                            : par1)))),
                            (((false ? var0 : '') !=
                                    (true
                                        ? MapBase.mapToString(({
                                              7: 'WTT7\u{1f600}e3',
                                              22: '',
                                              36: (var1
                                                  ? 'F'
                                                  : (var1 ? fld3_0[var2] : '')),
                                              37: 'l@a',
                                              85: (var1 ? '' : par3),
                                              82: 'eb',
                                              37: '11',
                                              41: var7[94]
                                            } ??
                                            var7))
                                        : (var1 ? var4 : par2)))
                                ? (~(var5[-71]))
                                : 9),
                            32,
                            if (bool.fromEnvironment(
                                fld3_0[var5[ZLibOption.MIN_MEM_LEVEL]]))
                              var5[(--par1)],
                            (par1--)
                          ],
                          for (int loc1 in {
                            for (int loc2 in [
                              ((!((Map.unmodifiable({
                                        86: var4,
                                        31: var0,
                                        85: (par3 + ''),
                                        91: (var1
                                            ? fld3_0[4]
                                            : '!M\u{1f600}!vOw'),
                                        45: '7T',
                                        19: 'fha+',
                                        38: (false ? '' : fld3_0[70])
                                      }) !=
                                      {
                                        92: '@4',
                                        41: var7[loc0],
                                        24: (foo3_0(0.06591134699771606)
                                            ? '\u2665)\u2665NnO+'
                                            : 'JM3Hn\u{1f600}'),
                                        26: 'aQ51Yz',
                                        64: var7[
                                            (-((var5[18] & (36).bitLength)))]
                                      })))
                                  ? (89 ^
                                      (((44 - par1) * -9223372034707292160) &
                                          var5[128]))
                                  : -46),
                              (fld3_2++),
                              ((([
                                            -89,
                                            var2,
                                            (fld3_2++),
                                            var5[-4294967264],
                                            -25,
                                            var2,
                                            var5[((!(var1))
                                                ? (var1 ? -3 : -81)
                                                : var5[loc0])],
                                            (var1
                                                ? par1
                                                : ((~((fld3_2++))) >>
                                                    (-((-(-64))))))
                                          ] ??
                                          foo2(var6, [
                                            4295032831
                                          ], {
                                            53: foo1_3(),
                                            94: var7[13],
                                            82: var7[-60],
                                            30: fld3_0[-9223372032559742976],
                                            98: foo1_3()
                                          })) !=
                                      var5)
                                  ? (--par1)
                                  : loc0),
                              56,
                              if (((var5[21]).isOdd ? true : false))
                                ((++par1) -
                                    (var1 ? var5[DateTime.january] : (par1--)))
                              else
                                fld3_2,
                              if ((!(var1))) 74,
                              (par1 ^ var5[26])
                            ])
                              (~(var2)),
                            for (int loc2 in {
                              6442450944,
                              Float32x4.ywyw,
                              -9223372032559804416,
                              (~(var5[var5[26]])),
                              Float32x4.xyxy,
                              (--fld3_2),
                              var5[98]
                            })
                              if (false) -26,
                            (~((-((-((-48 - -9223372036854775680))))))),
                            ...{
                              (-((var2--))),
                              if (true) -100663046 else var5[(~(par1))]
                            },
                            (~((~((fld3_2++))))),
                            ...{
                              ((List.filled(0, 26) ==
                                      [
                                        (-(-52)),
                                        -29,
                                        (--fld3_2),
                                        (0.22302566014161784).floor(),
                                        (par1 % -56)
                                      ])
                                  ? (var1
                                      ? (var2++)
                                      : ((!((!(true))))
                                          ? ((var1 || foo3_0(var3)) ? 76 : par1)
                                          : (-(-13))))
                                  : ((foo1_0((var1 ? fld3_0 : var7), var7,
                                              var3))
                                          .isEmpty
                                      ? 97
                                      : (var1 ? var2 : -9223372036854774784))),
                              (-(Float32x4.zyzw)),
                              (--var2)
                            }
                          })
                            ((var3 < (-(var3))) ? -9223372032559808000 : -71),
                          -100663046,
                          if ((var1
                              ? bool.fromEnvironment('vV0')
                              : (Map.from({
                                  78: '',
                                  49: '\u{1f600}\u{1f600}4Mz',
                                  70: fld3_0[par1],
                                  95: '\u{1f600}2tIYqE',
                                  43: (true ? 'baf-\u2665' : var4),
                                  30: var7[(-((-68 % ZLibOption.defaultLevel)))]
                                })).isNotEmpty))
                            -13
                          else
                            (var1 ? (-((-(var5[56])))) : (var2--)),
                          (~((~((-((var2++)))))))
                        ], {
                          88: ('bV\u{1f600}iqO').toLowerCase(),
                          42: '(hZ4S',
                          37: var7[-79],
                          36: var0
                        })));
            }
          }
          {
            int loc0 = 0;
            do {
              try {
                print(foo2(
                    fld3_1,
                    (fld3_0[var5[-12]]).codeUnits,
                    (({
                              36: var4,
                              30: '0\u{1f600}EYWqr',
                              66: 'S',
                              3: '+J3Gj',
                              71: '\u{1f600}-q',
                              13: 'V3QN',
                              34: ''
                            } ??
                            {
                              54: fld3_0[(var2--)],
                              74: (foo3_0(
                                      ((-(var3)) * (0.8613045491468889 + var3)))
                                  ? var7[78]
                                  : (((var1 ? (47).isEven : var1) ? true : true)
                                      ? (var4 ?? 'UzK')
                                      : 'fH1smd')),
                              12: '\u2665',
                              18: 'V'
                            }) ??
                        var7)));
              } catch (exception, stackTrace) {
                fld3_1 = foo0();
                for (int loc1 = 0; loc1 < 29; loc1++) {
                  if (var1) {
                    {
                      int loc2 = 0;
                      do {
                        var5 = (foo3_0(var3)
                            ? [
                                ((--par1) ^ (~(93))),
                                if ((var3).isFinite)
                                  for (int loc3 in [
                                    -5,
                                    Int32x4.zxyy,
                                    (true
                                        ? var5[var5[(var1 ? -23 : var5[68])]]
                                        : -99),
                                    ((!(var1))
                                        ? ((false
                                                ? var1
                                                : foo3_0(0.3133865362301862))
                                            ? Float64List.bytesPerElement
                                            : [
                                                Float32x4.yxzx,
                                                if (var1)
                                                  (false ? 40 : 85)
                                                else
                                                  ((String.fromCharCode((foo3_0(
                                                                  0.414460580942719)
                                                              ? var5[-14]
                                                              : var2)) ==
                                                          'mII\u{1f600}zkM')
                                                      ? var5[(~(-51))]
                                                      : ((var1
                                                              ? (!(var1))
                                                              : var1)
                                                          ? var5[0]
                                                          : (-(var2))))
                                              ][5])
                                        : fld3_2),
                                    (par1++),
                                    -72,
                                    Int32x4.zzxy
                                  ])
                                    Int32x4.zyww
                                else
                                  Int32x4.wxyz
                              ]
                            : [
                                ...[
                                  if ((false ? false : var1)) (-(52)),
                                  (++par1),
                                  (par1--),
                                  (-((-([
                                    (((var0 + fld3_0[(++var2)])).isNotEmpty
                                        ? Float32x4.yzxw
                                        : var5[35])
                                  ][loc0])))),
                                  (~(-17))
                                ],
                                38,
                                ...[
                                  (var1 ? (par1++) : -10),
                                  if (true) -62 else var2,
                                  if ((!((var3).isFinite)))
                                    Int32x4.xxzz
                                  else
                                    -45
                                ],
                                if ((true || false)) (-(-93)),
                                (--fld3_2),
                                ([
                                      (fld3_2--),
                                      if ((base64UrlEncode(var5) == 'RY'))
                                        (++fld3_2)
                                      else
                                        -9223372032559808383,
                                      Float32x4.zyxy,
                                      loc0,
                                      -55,
                                      if (('O \u{1f600}e\u2665').isNotEmpty)
                                        if (var1)
                                          (--var2)
                                        else
                                          for (int loc3 in {
                                            loc0,
                                            (~((--var2))),
                                            (-(-35)),
                                            Float32x4.xxyw,
                                            65,
                                            -4,
                                            -4194304251,
                                            -54
                                          })
                                            (((0.671280258888436 ==
                                                        (0.16535430333243706 *
                                                            0.18316039550464436)) ||
                                                    var1)
                                                ? var5[12]
                                                : (~((--var2))))
                                      else if (false)
                                        if (var1) (-(Int32x4.zzwx)) else loc2
                                      else
                                        Int32x4.yzyw
                                    ][loc1] *
                                    (--par1)),
                                (-71 * 38)
                              ]);
                      } while (++loc2 < 89);
                    }
                  } else {
                    {
                      int loc2 = 0;
                      do {
                        fld3_0 ??= ((((Map.unmodifiable(var7)).isEmpty ||
                                    (!(({
                                      11: 'v+MHeiB',
                                      48: var7[(true
                                          ? ((var2--) ?? fld3_2)
                                          : var5[(fld3_2--)])],
                                      52: '(('
                                    }).isEmpty)))
                                ? fld3_0
                                : {
                                    39: foo1_3(),
                                    21: 'IXzJ+',
                                    76: 'K2C#',
                                    16: ('\u{1f600}Gh' + '#i'),
                                    62: foo1_3(),
                                    19: foo1_3(),
                                    32: par3,
                                    for (int loc3 in [
                                      (par1--),
                                      -66,
                                      -96,
                                      -35,
                                      Float32x4.zzyz
                                    ])
                                      72: 'y vxi'
                                  }) ??
                            {13: par2});
                        switch (4096) {
                          case 3159134388:
                            {
                              /// Single-line documentation comment.
                              {
                                int loc3 = 0;
                                do {
                                  fld3_0 ??= foo1(
                                      var5,
                                      ((((true ? par2 : var7[var5[loc1]]))
                                                  .isNotEmpty
                                              ? 9
                                              : -55) !=
                                          var5[-36]));
                                  fld3_1 = foo0();
                                } while (++loc3 < 79);
                              }
                            }
                            break;
                          case 3159134393:
                            {
                              throw Int32x4.zxxw;
                            }
                            break;
                        }
                      } while (++loc2 < 77);
                    }
                  }
                }
              }
            } while (++loc0 < 98);
          }
        }
        break;
    }
    /*
     * Multi-line
     * comment.
     */
    return ((0.7728524536008519).isNaN ? 'BjzeSsJ' : foo1_3());
  }

  void run() {
    super.run();
    var5 ??= var5;
    print({4294968296});
  }
}

main() {
  int count = 0;
  try {
    foo0();
  } catch (e, st) {
    count++;
  }
  try {
    foo1(('  MQz').codeUnits, var1);
  } catch (e, st) {
    count++;
  }
  try {
    foo2(
        (var6).toSet(),
        (var1
            ? [-9223372036854775681, -66, 9223372032559874047, -3, 74]
            : var5),
        Map.identity());
  } catch (e, st) {
    count++;
  }
  try {
    X0().foo0_0(var7);
  } catch (e, st) {
    count++;
  }
  try {
    X1().foo1_0(
        (false
            ? {
                7: 'QMNg',
                12: 'wzc5-Iq',
                63: '29an-z',
                86: 'sF5',
                59: '\u2665L',
                43: 'k',
                62: 'NvF\u{1f600}k',
                84: 'ZW 1-o'
              }
            : var7),
        {
          28: '@smXqKl',
          66: 'oL',
          if (false) 74: 'B' else 81: 'X',
          if (false) 18: 'j' else 25: 'N',
          44: '\u{1f600}lrx8m',
          20: 'hC',
          73: 'q',
          63: '\u{1f600}nE'
        },
        0.18875619647922648);
  } catch (e, st) {
    count++;
  }
  try {
    X1().foo1_1((-((++var2))));
  } catch (e, st) {
    count++;
  }
  try {
    X1().foo1_2((var1
        ? (false
            ? (true ? var7[((!(var1)) ? var5[Int32x4.xxyx] : 3)] : var4)
            : Uri.encodeComponent(('yd' ?? (var0).padLeft(1, 'Q'))))
        : var7[-2147483649]));
  } catch (e, st) {
    count++;
  }
  try {
    X1().foo1_3();
  } catch (e, st) {
    count++;
  }
  try {
    X2().foo2_0(Int32x4.xyyw);
  } catch (e, st) {
    count++;
  }
  try {
    X2().foo2_1((!(((!(var1)) && (!((var1 ? false : var1)))))));
  } catch (e, st) {
    count++;
  }
  try {
    X2().foo2_2(var7, ((-(var5[(--var2)])) << 98));
  } catch (e, st) {
    count++;
  }
  try {
    X3().foo3_0(0.37767598562234317);
  } catch (e, st) {
    count++;
  }
  try {
    X3().foo3_1(
        -6, var0, (Uri.decodeComponent('yQg') + ((var4 ?? var4) + var0)));
  } catch (e, st) {
    count++;
  }
  try {
    X3().foo1_0(
        Map.unmodifiable({77: 'hG'}),
        ((false
                ? {
                    88: 'Sv-EbnG',
                    73: 'G',
                    46: 'O#',
                    16: 'm1nf(',
                    91: 'F',
                    11: 'Q+O@K',
                    70: '3q\u2665BJ'
                  }
                : Map.identity()) ??
            {
              68: 'r',
              56: 'IH&',
              31: '9cqu',
              49: '8ug',
              84: 'mR2VyC',
              41: 'gk&(asy'
            }),
        (var3 * sin(var3)));
  } catch (e, st) {
    count++;
  }
  try {
    X3().run();
  } catch (e, st) {
    count++;
  } finally {}
  Expect.equals(-47639, var2);
  Expect.equals(9, count);
}